Manage and cache data about a part of the map. More...

#include <map.h>

Inheritance diagram for map:

Classes
struct	apparent_light_info

Public Member Functions
	map (int mapsize=MAPSIZE, bool zlev=false)

	map (bool zlev)

virtual	~map ()

map &	operator= (const map &)=delete

map &	operator= (map &&)

void	set_transparency_cache_dirty (const int zlev)
	Sets a dirty flag on the a given cache. More...

void	set_transparency_cache_dirty (const tripoint &p)

void	set_seen_cache_dirty (const tripoint change_location)

void	set_seen_cache_dirty (const int zlevel)

void	set_outside_cache_dirty (const int zlev)

void	set_floor_cache_dirty (const int zlev)

void	set_suspension_cache_dirty (const int zlev)

void	set_pathfinding_cache_dirty (int zlev)

void	set_memory_seen_cache_dirty (const tripoint &p)

void	invalidate_map_cache (const int zlev)

bool	check_seen_cache (const tripoint &p) const

bool	check_and_set_seen_cache (const tripoint &p) const

void	on_vehicle_moved (int smz)
	Callback invoked when a vehicle has moved. More...

lit_level	apparent_light_at (const tripoint &p, const visibility_variables &cache) const
	Determine the visible light level for a tile, based on light_at for the tile, vision distance, etc. More...

visibility_type	get_visibility (lit_level ll, const visibility_variables &cache) const

std::tuple< maptile, maptile, maptile >	get_wind_blockers (const int &winddirection, const tripoint &pos)

void	draw (const catacurses::window &w, const tripoint &center)
	Draw a visible part of the map into `w`. More...

void	drawsq (const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
	Draw the map tile at the given coordinate. More...

void	save ()
	Add currently loaded submaps (in grid) to the mapbuffer. More...

void	load (const tripoint &w, bool update_vehicles, bool pump_events=false)
	Load submaps into grid. More...

void	load (const tripoint_abs_sm &w, bool update_vehicles, bool pump_events=false)

void	shift (point s)
	Shift the map along the vector s. More...

void	vertical_shift (int newz)
	Moves the map vertically to (not by!) newz. More...

void	clear_spawns ()

void	clear_traps ()

maptile	maptile_at (const tripoint &p) const

maptile	maptile_at (const tripoint &p)

int	move_cost (const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
	Calculate the cost to move past the tile at p. More...

int	move_cost (point p, const vehicle *ignored_vehicle=nullptr) const

bool	impassable (const tripoint &p) const

bool	impassable (point p) const

bool	passable (const tripoint &p) const

bool	passable (point p) const

bool	is_wall_adjacent (const tripoint &center) const

int	move_cost_ter_furn (const tripoint &p) const
	Similar behavior to `move_cost()`, but ignores vehicles. More...

int	move_cost_ter_furn (point p) const

bool	impassable_ter_furn (const tripoint &p) const

bool	passable_ter_furn (const tripoint &p) const

int	combined_movecost (const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
	Cost to move out of one tile and into the next. More...

bool	valid_move (const tripoint &from, const tripoint &to, bool bash=false, bool flying=false, bool via_ramp=false) const
	Returns true if a creature could walk from `from` to `to` in one step. More...

double	ranged_target_size (const tripoint &p) const
	Size of map objects at `p` for purposes of ranged combat. More...

bool	sees (const tripoint &F, const tripoint &T, int range) const
	Returns whether `F` sees `T` with a view range of `range`. More...

int	obstacle_coverage (const tripoint &loc1, const tripoint &loc2) const
	Returns coverage of target in relation to the observer. More...

int	coverage (const tripoint &p) const
	Returns coverage value of the tile. More...

bool	clear_path (const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
	Check whether there's a direct line of sight between `F` and `T` with the additional movecost restraints. More...

bool	obstructed_by_vehicle_rotation (const tripoint &from, const tripoint &to) const
	Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent. More...

bool	obscured_by_vehicle_rotation (const tripoint &from, const tripoint &to) const
	Checks if a rotated vehicle is blocking diagonal vision, tripoints must be adjacent. More...

void	reachable_flood_steps (std::vector< tripoint > &reachable_pts, const tripoint &f, int range, int cost_min, int cost_max) const
	Populates a vector of points that are reachable within a number of steps from a point. More...

std::vector< tripoint >	find_clear_path (const tripoint &source, const tripoint &destination) const
	Iteratively tries Bresenham lines with different biases until it finds a clear line or decides there isn't one. More...

bool	accessible_items (const tripoint &t) const
	Check whether the player can access the items located . More...

std::vector< tripoint >	get_dir_circle (const tripoint &f, const tripoint &t) const
	Calculate next search points surrounding the current position. More...

std::vector< tripoint >	route (const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
	Calculate the best path using A*. More...

VehicleList	get_vehicles ()

void	add_vehicle_to_cache (vehicle *)

void	clear_vehicle_point_from_cache (vehicle *veh, const tripoint &pt)

void	update_vehicle_cache (vehicle *, int old_zlevel)

void	reset_vehicle_cache ()

void	clear_vehicle_cache ()

void	clear_vehicle_list (int zlev)

void	update_vehicle_list (const submap *to, int zlev)

bool	check_vehicle_zones (int zlev)

std::vector< zone_data * >	get_vehicle_zones (int zlev)

void	register_vehicle_zone (vehicle *, int zlev)

bool	deregister_vehicle_zone (zone_data &zone)

std::unique_ptr< vehicle >	detach_vehicle (vehicle *veh)

void	destroy_vehicle (vehicle *veh)

void	vehmove ()

bool	vehproceed (VehicleList &vehicle_list)

VehicleList	get_vehicles (const tripoint &start, const tripoint &end)

optional_vpart_position	veh_at (const tripoint &p) const
	Checks if tile is occupied by vehicle and by which part. More...

optional_vpart_position	veh_at (const tripoint_abs_ms &p) const

vehicle *	veh_at_internal (const tripoint &p, int &part_num)

const vehicle *	veh_at_internal (const tripoint &p, int &part_num) const

void	board_vehicle (const tripoint &p, player *pl)

void	unboard_vehicle (const vpart_reference &, Character *passenger, bool dead_passenger=false)

void	unboard_vehicle (const tripoint &p, bool dead_passenger=false)

bool	displace_vehicle (vehicle &veh, const tripoint &dp)

void	shift_vehicle_z (vehicle &veh, int z_shift)

bool	displace_water (const tripoint &dp)

float	vehicle_wheel_traction (const vehicle &veh, bool ignore_movement_modifiers=false) const

float	vehicle_vehicle_collision (vehicle &veh, vehicle &veh2, const std::vector< veh_collision > &collisions)

units::angle	shake_vehicle (vehicle &veh, int velocity_before, units::angle direction)

vehicle *	move_vehicle (vehicle &veh, const tripoint &dp, const tileray &facing)

void	set (const tripoint &p, const ter_id &new_terrain, const furn_id &new_furniture)

void	set (point p, const ter_id &new_terrain, const furn_id &new_furniture)

std::string	name (const tripoint &p)

std::string	name (point p)

std::string	disp_name (const tripoint &p)

std::string	obstacle_name (const tripoint &p)
	Returns the name of the obstacle at p that might be blocking movement/projectiles/etc. More...

bool	has_furn (const tripoint &p) const

bool	has_furn (point p) const

furn_id	furn (const tripoint &p) const

furn_id	furn (point p) const

void	furn_set (const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
	Sets the furniture at given position. More...

void	furn_set (point p, const furn_id &new_furniture)

std::string	furnname (const tripoint &p)

std::string	furnname (point p)

bool	can_move_furniture (const tripoint &pos, player *p=nullptr)

ter_id	ter (const tripoint &p) const

ter_id	ter (point p) const

uint8_t	get_known_connections (const tripoint &p, int connect_group, const std::map< tripoint, ter_id > &override={}) const

const harvest_id &	get_harvest (const tripoint &p) const
	Returns the full harvest list, for spawning. More...

const std::set< std::string > &	get_harvest_names (const tripoint &p) const
	Returns names of the items that would be dropped. More...

ter_id	get_ter_transforms_into (const tripoint &p) const

furn_id	get_furn_transforms_into (const tripoint &p) const

bool	ter_set (const tripoint &p, const ter_id &new_terrain)

bool	ter_set (point p, const ter_id &new_terrain)

std::string	tername (const tripoint &p) const

std::string	tername (point p) const

bool	has_nearby_fire (const tripoint &p, int radius=1)

bool	has_nearby_table (const tripoint &p, int radius=1)
	Check whether a table/workbench/vehicle kitchen or other flat surface is nearby that could be used for crafting or eating. More...

bool	has_nearby_chair (const tripoint &p, int radius=1)
	Check whether a chair or vehicle seat is nearby. More...

bool	sees_some_items (const tripoint &p, const Creature &who) const
	Check if creature can see some items at p. More...

bool	sees_some_items (const tripoint &p, const tripoint &from) const

bool	could_see_items (const tripoint &p, const Creature &who) const
	Check if the creature could see items at p if there were any items. More...

bool	could_see_items (const tripoint &p, const tripoint &from) const

bool	has_items (const tripoint &p) const
	Checks for existence of items. More...

void	examine (Character &p, const tripoint &pos)
	Calls the examine function of furniture or terrain at given tile, for given character. More...

bool	is_harvestable (const tripoint &pos) const
	Returns true if point at pos is harvestable right now, with no extra tools. More...

std::string	features (const tripoint &p)

std::string	features (point p)

bool	has_flag (const std::string &flag, const tripoint &p) const

bool	has_flag (const std::string &flag, point p) const

bool	can_put_items (const tripoint &p) const

bool	can_put_items (point p) const

bool	can_put_items_ter_furn (const tripoint &p) const

bool	can_put_items_ter_furn (point p) const

bool	has_flag_ter (const std::string &flag, const tripoint &p) const

bool	has_flag_ter (const std::string &flag, point p) const

bool	has_flag_furn (const std::string &flag, const tripoint &p) const

bool	has_flag_furn (const std::string &flag, point p) const

bool	has_flag_vpart (const std::string &flag, const tripoint &p) const

bool	has_flag_furn_or_vpart (const std::string &flag, const tripoint &p) const

bool	has_flag_ter_or_furn (const std::string &flag, const tripoint &p) const

bool	has_flag_ter_or_furn (const std::string &flag, point p) const

bool	has_flag (ter_bitflags flag, const tripoint &p) const

bool	has_flag (ter_bitflags flag, point p) const

bool	has_flag_ter (ter_bitflags flag, const tripoint &p) const

bool	has_flag_ter (ter_bitflags flag, point p) const

bool	has_flag_furn (ter_bitflags flag, const tripoint &p) const

bool	has_flag_furn (ter_bitflags flag, point p) const

bool	has_flag_ter_or_furn (ter_bitflags flag, const tripoint &p) const

bool	has_flag_ter_or_furn (ter_bitflags flag, point p) const

bool	is_bashable (const tripoint &p, bool allow_floor=false) const
	Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p. More...

bool	is_bashable (point p) const

bool	is_bashable_ter (const tripoint &p, bool allow_floor=false) const
	Returns true if the terrain at p is bashable. More...

bool	is_bashable_ter (point p) const

bool	is_bashable_furn (const tripoint &p) const
	Returns true if the furniture at p is bashable. More...

bool	is_bashable_furn (point p) const

bool	is_bashable_ter_furn (const tripoint &p, bool allow_floor=false) const
	Returns true if the furniture or terrain at p is bashable. More...

bool	is_bashable_ter_furn (point p) const

int	bash_strength (const tripoint &p, bool allow_floor=false) const
	Returns max_str of the furniture or terrain at p. More...

int	bash_strength (point p) const

int	bash_resistance (const tripoint &p, bool allow_floor=false) const
	Returns min_str of the furniture or terrain at p. More...

int	bash_resistance (point p) const

int	bash_rating (int str, const tripoint &p, bool allow_floor=false) const
	Returns a success rating from -1 to 10 for a given tile based on a set strength, used for AI movement planning Values roughly correspond to 10% increment chances of success on a given bash, rounded down. More...

int	bash_rating (const int str, point p) const

void	make_rubble (const tripoint &p, const furn_id &rubble_type, const ter_id &floor_type, bool overwrite=false)
	Generates rubble at the given location, if overwrite is true it just writes on top of what currently exists floor_type is only used if there is a non-bashable wall at the location or with overwrite = true. More...

void	make_rubble (const tripoint &p, const furn_id &rubble_type)

void	make_rubble (const tripoint &p)

bool	is_outside (const tripoint &p) const

bool	is_outside (point p) const

bool	is_divable (const tripoint &p) const
	Returns whether or not the terrain at the given location can be dived into (by monsters that can swim or are aquatic or non-breathing). More...

bool	is_divable (point p) const

bool	is_water_shallow_current (const tripoint &p) const

bool	is_water_shallow_current (point p) const

bool	is_last_ter_wall (bool no_furn, point p, point max, direction dir) const
	Check if the last terrain is wall in direction NORTH, SOUTH, WEST or EAST. More...

bool	tinder_at (const tripoint &p)
	Checks if there are any tinder flagged items on the tile. More...

bool	flammable_items_at (const tripoint &p, int threshold=0)
	Checks if there are any flammable items on the tile. More...

bool	is_flammable (const tripoint &p)
	Returns true if there is a flammable item or field or the furn/terrain is flammable at p. More...

point	random_outdoor_tile ()

void	draw_line_ter (const ter_id &type, point p1, point p2)

void	draw_line_furn (const furn_id &type, point p1, point p2)

void	draw_fill_background (const ter_id &type)

void	draw_fill_background (ter_id(*f)())

void	draw_fill_background (const weighted_int_list< ter_id > &f)

void	draw_square_ter (const ter_id &type, point p1, point p2)

void	draw_square_furn (const furn_id &type, point p1, point p2)

void	draw_square_ter (ter_id(*f)(), point p1, point p2)

void	draw_square_ter (const weighted_int_list< ter_id > &f, point p1, point p2)

void	draw_rough_circle_ter (const ter_id &type, point p, int rad)

void	draw_rough_circle_furn (const furn_id &type, point p, int rad)

void	draw_circle_ter (const ter_id &type, const rl_vec2d &p, double rad)

void	draw_circle_ter (const ter_id &type, point p, int rad)

void	draw_circle_furn (const furn_id &type, point p, int rad)

void	add_corpse (const tripoint &p)

void	translate (const ter_id &from, const ter_id &to)

void	translate_radius (const ter_id &from, const ter_id &to, float radi, const tripoint &p, bool same_submap=false, bool toggle_between=false)

bool	close_door (const tripoint &p, bool inside, bool check_only)

bool	open_door (const tripoint &p, bool inside, bool check_only=false)

void	batter (const tripoint &p, int power, int tries=1, bool silent=false)
	bash a square for a set number of times at set power. More...

void	destroy (const tripoint &p, bool silent=false)
	Keeps bashing a square until it can't be bashed anymore. More...

void	destroy_furn (const tripoint &p, bool silent=false)
	Keeps bashing a square until there is no more furniture. More...

void	crush (const tripoint &p)

void	shoot (const tripoint &p, projectile &proj, bool hit_items)

int	collapse_check (const tripoint &p)
	Checks if a square should collapse, returns the X for the one_in(X) collapse chance. More...

void	collapse_at (const tripoint &p, bool silent, bool was_supporting=false, bool destroy_pos=true)
	Causes a collapse at p, such as from destroying a wall. More...

void	propagate_suspension_check (const tripoint &point)
	Checks surrounding tiles for suspension, and has them check for collapse. More...

void	collapse_invalid_suspension (const tripoint &point)
	Triggers a recursive collapse of suspended tiles based on their support validity. More...

bool	is_suspension_valid (const tripoint &point)
	Checks the four orientations in which a suspended tile could be valid, and returns if the tile is valid. More...

void	smash_trap (const tripoint &p, const int power, const std::string &cause_message)
	Tries to smash the trap at the given tripoint. More...

void	smash_items (const tripoint &p, int power, const std::string &cause_message, bool do_destroy)
	Tries to smash the items at the given tripoint. More...

bash_results	bash (const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
	Returns a pair where first is whether anything was smashed and second is if it was destroyed. More...

bash_results	bash_vehicle (const tripoint &p, const bash_params &params)

bash_results	bash_ter_furn (const tripoint &p, const bash_params &params)

bool	hit_with_acid (const tripoint &p)

bool	hit_with_fire (const tripoint &p)

bool	has_adjacent_furniture_with (const tripoint &p, const std::function< bool(const furn_t &)> &filter)
	Returns true if there is furniture for which filter returns true in a 1 tile radius of p. More...

bool	mop_spills (const tripoint &p)
	Remove moppable fields/items at this location. More...

void	decay_fields_and_scent (const time_duration &amount)
	Moved here from weather.cpp for speed. More...

std::string	get_signage (const tripoint &p) const

void	set_signage (const tripoint &p, const std::string &message) const

void	delete_signage (const tripoint &p) const

int	get_radiation (const tripoint &p) const

void	set_radiation (const tripoint &p, int value)

void	set_radiation (point p, const int value)

void	adjust_radiation (const tripoint &p, int delta)
	Increment the radiation in the given tile by the given delta (decrement it if delta is negative) More...

void	adjust_radiation (point p, const int delta)

int	get_temperature (const tripoint &p) const

void	set_temperature (const tripoint &p, int temperature)

void	set_temperature (point p, int new_temperature)

std::vector< tripoint >	check_submap_active_item_consistency ()

map_stack	i_at (const tripoint &p)

map_stack	i_at (point p)

item	water_from (const tripoint &p)

void	i_clear (const tripoint &p)

void	i_clear (point p)

map_stack::iterator	i_rem (const tripoint &p, map_stack::const_iterator it)

map_stack::iterator	i_rem (point location, map_stack::const_iterator it)

void	i_rem (const tripoint &p, item *it)

void	i_rem (point p, item *it)

void	spawn_artifact (const tripoint &p)

void	spawn_natural_artifact (const tripoint &p, artifact_natural_property prop)

void	spawn_item (const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)

void	spawn_item (point p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)

void	spawn_item (const tripoint &p, const std::string &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)

void	spawn_item (point p, const std::string &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)

units::volume	max_volume (const tripoint &p)

units::volume	free_volume (const tripoint &p)

units::volume	stored_volume (const tripoint &p)

item &	add_item_or_charges (const tripoint &pos, item obj, bool overflow=true)
	Adds an item to map tile or stacks charges. More...

item &	add_item_or_charges (point p, item obj, bool overflow=true)

item &	add_item (const tripoint &p, item new_item)
	Place an item on the map, despite the parameter name, this is not necessarily a new item. More...

void	add_item (point p, item new_item)

item &	spawn_an_item (const tripoint &p, item new_item, int charges, int damlevel)

void	spawn_an_item (point p, item new_item, int charges, int damlevel)

void	make_active (item_location &loc)
	Update an item's active status, for example when adding hot or perishable liquid to a container. More...

void	update_lum (item_location &loc, bool add)
	Update luminosity before and after item's transformation. More...

Static Public Member Functions
static apparent_light_info	apparent_light_helper (const level_cache &map_cache, const tripoint &p)
	Helper function for light claculation; exposed here for map editor. More...

Private Member Functions
maptile	maptile_at_internal (const tripoint &p) const

maptile	maptile_at_internal (const tripoint &p)

std::pair< tripoint, maptile >	maptile_has_bounds (const tripoint &p, bool bounds_checked)

std::array< std::pair< tripoint, maptile >, 8 >	get_neighbors (const tripoint &p)

void	spread_gas (field_entry &cur, const tripoint &p, int percent_spread, const time_duration &outdoor_age_speedup, scent_block &sblk)

void	create_hot_air (const tripoint &p, int intensity)

bool	gas_can_spread_to (field_entry &cur, const tripoint &src, const tripoint &dst)

void	gas_spread_to (field_entry &cur, maptile &dst, const tripoint &p)

int	burn_body_part (player &u, field_entry &cur, body_part bp, int scale)

bool	sees (const tripoint &F, const tripoint &T, int range, int &bresenham_slope) const
	Don't expose the slope adjust outside map functions. More...

Friends
class	editmap

class	visitable< map_cursor >

Consume items on the map
The functions here consume accessible items / item charges on the map or in vehicles around the player (whose positions is given as origin). They return a list of copies of the consumed items (with the actually consumed charges in it). The quantity / amount parameter will be reduced by the number of items/charges removed. If all required items could be removed from the map, the quantity/amount will be 0, otherwise it will contain a positive value and the remaining items must be gathered from somewhere else.
enum	iteration_state { ITER_CONTINUE = 0 , ITER_SKIP_SUBMAP , ITER_SKIP_ZLEVEL , ITER_FINISH }
	Enum used by functors in `function_over` to control execution. More...

std::set< tripoint >	support_cache_dirty

std::vector< submap * >	grid
	The list of currently loaded submaps. More...

std::vector< std::vector< tripoint > >	traplocs
	This vector contains an entry for each trap type, it has therefor the same size as the traplist vector. More...

std::vector< tripoint >	field_furn_locs
	Vector of tripoints containing active field-emitting furniture. More...

std::array< std::unique_ptr< level_cache >, OVERMAP_LAYERS >	caches
	Holds caches for visibility, light, transparency and vehicles. More...

std::array< std::unique_ptr< pathfinding_cache >, OVERMAP_LAYERS >	pathfinding_caches

std::set< tripoint >	submaps_with_active_items
	Set of submaps that contain active items in absolute coordinates. More...

lru_cache< point, char >	skew_vision_cache
	Cache of coordinate pairs recently checked for visibility. More...

VehicleList	last_full_vehicle_list
	Vehicle list doesn't change often, but is pretty expensive. More...

bool	last_full_vehicle_list_dirty = true

visibility_variables	visibility_variables_cache

std::optional< std::pair< tripoint, int > >	max_populated_zlev = std::nullopt

std::set< vehicle * >	dirty_vehicle_list

int	my_MAPSIZE

bool	zlevels

vision_adjustment	vision_transparency_cache [8] = { VISION_ADJUST_NONE }

tripoint	abs_sub
	Absolute coordinates of first submap (get_submap_at(0,0)) This is in submap coordinates (see overmapbuffer for explanation). More...

std::list< item >	use_amount_square (const tripoint &p, const itype_id &type, int &quantity, const std::function< bool(const item &)> &filter=return_true< item >)

std::list< item >	use_amount (const tripoint &origin, int range, const itype_id &type, int &quantity, const std::function< bool(const item &)> &filter=return_true< item >)

std::list< item >	use_charges (const tripoint &origin, int range, const itype_id &type, int &quantity, const std::function< bool(const item &)> &filter=return_true< item >, basecamp *bcp=nullptr)

std::vector< item * >	place_items (const item_group_id &loc, int chance, const tripoint &p1, const tripoint &p2, bool ongrass, const time_point &turn, int magazine=0, int ammo=0)
	Place items from item group in the rectangle f - t. More...

std::vector< item * >	place_items (const item_group_id &loc, int chance, point p1, point p2, bool ongrass, const time_point &turn, int magazine=0, int ammo=0)

std::vector< item * >	put_items_from_loc (const item_group_id &loc, const tripoint &p, const time_point &turn=calendar::start_of_cataclysm)
	Place items from an item group at p. More...

std::vector< item * >	spawn_items (const tripoint &p, const std::vector< item > &new_items)

void	spawn_items (point p, const std::vector< item > &new_items)

void	create_anomaly (const tripoint &p, artifact_natural_property prop, bool create_rubble=true)

void	create_anomaly (point cp, artifact_natural_property prop, bool create_rubble=true)

void	partial_con_set (const tripoint &p, const partial_con &con)

void	partial_con_remove (const tripoint &p)

partial_con *	partial_con_at (const tripoint &p)

void	trap_set (const tripoint &p, const trap_id &type)

const trap &	tr_at (const tripoint &p) const

bool	can_see_trap_at (const tripoint &p, const Character &c) const
	See trap::can_see, which is called for the trap here. More...

void	disarm_trap (const tripoint &p)

void	remove_trap (const tripoint &p)

const std::vector< tripoint > &	get_furn_field_locations () const

const std::vector< tripoint > &	trap_locations (const trap_id &type) const

void	create_burnproducts (const tripoint &p, const item &fuel, const units::mass &burned_mass)

void	process_fields ()

void	process_fields_in_submap (submap *current_submap, const tripoint &submap_pos)

void	creature_in_field (Creature &critter)
	Apply field effects to the creature when it's on a square with fields. More...

void	creature_on_trap (Creature &critter, bool may_avoid=true)
	Apply trap effects to the creature, similar to creature_in_field. More...

const field &	field_at (const tripoint &p) const
	Get the fields that are here. More...

field &	field_at (const tripoint &p)
	Gets fields that are here. More...

time_duration	get_field_age (const tripoint &p, const field_type_id &type) const
	Get the age of a field entry (field_entry::age), if there is no field of that type, returns `-1_turns`. More...

int	get_field_intensity (const tripoint &p, const field_type_id &type) const
	Get the intensity of a field entry (field_entry::intensity), if there is no field of that type, returns 0. More...

time_duration	mod_field_age (const tripoint &p, const field_type_id &type, const time_duration &offset)
	Increment/decrement age of field entry at point. More...

int	mod_field_intensity (const tripoint &p, const field_type_id &type, int offset)
	Increment/decrement intensity of field entry at point, creating if not present, removing if intensity becomes 0. More...

time_duration	set_field_age (const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
	Set age of field entry at point. More...

int	set_field_intensity (const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
	Set intensity of field entry at point, creating if not present, removing if intensity becomes 0. More...

bool	has_field_at (const tripoint &p, bool check_bounds=true)

field_entry *	get_field (const tripoint &p, const field_type_id &type)
	Get field of specific type at point. More...

bool	dangerous_field_at (const tripoint &p)

bool	add_field (const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
	Add field entry at point, or set intensity if present. More...

void	remove_field (const tripoint &p, const field_type_id &field_to_remove)
	Remove field entry at xy, ignored if the field entry is not present. More...

void	add_splatter (const field_type_id &type, const tripoint &where, int intensity=1)

void	add_splatter_trail (const field_type_id &type, const tripoint &from, const tripoint &to)

void	add_splash (const field_type_id &type, const tripoint &center, int radius, int intensity)

void	propagate_field (const tripoint &center, const field_type_id &type, int amount, int max_intensity=0)

void	emit_field (const tripoint &pos, const emit_id &src, float mul=1.0f)
	Runs one cycle of emission src which may result in propagation of fields. More...

void	scent_blockers (std::array< std::array< char, MAPSIZE_X >, MAPSIZE_Y > &scent_transfer, point min, point max)
	Build the map of scent-resistant tiles. More...

computer *	computer_at (const tripoint &p)

computer *	add_computer (const tripoint &p, const std::string &name, int security)

void	add_camp (const tripoint_abs_omt &omt_pos, const std::string &name)

void	remove_submap_camp (const tripoint &)

basecamp	hoist_submap_camp (const tripoint &p)

bool	point_within_camp (const tripoint &point_check) const

bool	has_graffiti_at (const tripoint &p) const

const std::string &	graffiti_at (const tripoint &p) const

void	set_graffiti (const tripoint &p, const std::string &contents)

void	delete_graffiti (const tripoint &p)

int	climb_difficulty (const tripoint &p) const
	Checks 3x3 block centered on p for terrain to climb. More...

bool	has_floor (const tripoint &p) const

bool	floor_between (const tripoint &first, const tripoint &second) const
	Checks if there's a floor between the two tiles. More...

bool	supports_above (const tripoint &p) const
	Does this tile support vehicles and furniture above it. More...

bool	has_floor_or_support (const tripoint &p) const

void	drop_everything (const tripoint &p)
	Handles map objects of given type (not creatures) falling down. More...

void	drop_furniture (const tripoint &p)

void	drop_items (const tripoint &p)

void	drop_vehicle (const tripoint &p)

void	drop_fields (const tripoint &p)

void	process_falling ()
	Invoked drop_everything on cached dirty tiles. More...

bool	is_cornerfloor (const tripoint &p) const

void	generate (const tripoint &p, const time_point &when)

void	place_spawns (const mongroup_id &group, int chance, point p1, point p2, float density, bool individual=false, bool friendly=false, const std::string &name="NONE", int mission_id=-1)

void	place_gas_pump (point p, int charges, const std::string &fuel_type)

void	place_gas_pump (point p, int charges)

void	place_toilet (point p, int charges=6 *4)

void	place_vending (point p, const item_group_id &type, bool reinforced=false)

character_id	place_npc (point p, const string_id< npc_template > &type, bool force=false)

void	apply_faction_ownership (point p1, point p2, const faction_id &id)

void	add_spawn (const mtype_id &type, int count, const tripoint &p, bool friendly=false, int faction_id=-1, int mission_id=-1, const std::string &name="NONE") const

void	do_vehicle_caching (int z)

void	build_map_cache (int zlev, bool skip_lightmap=false)

void	build_obstacle_cache (const tripoint &start, const tripoint &end, float(&obstacle_cache)[MAPSIZE_X][MAPSIZE_Y])

vehicle *	add_vehicle (const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)

vehicle *	add_vehicle (const vgroup_id &type, point p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)

vehicle *	add_vehicle (const vproto_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)

vehicle *	add_vehicle (const vproto_id &type, point p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)

float	light_transparency (const tripoint &p) const

lit_level	light_at (const tripoint &p) const

float	ambient_light_at (const tripoint &p) const

bool	is_transparent (const tripoint &p) const
	Returns whether the tile at `p` is transparent(you can look past it). More...

bool	pl_sees (const tripoint &t, int max_range) const
	Whether the player character (g->u) can see the given square (local map coordinates). More...

bool	pl_line_of_sight (const tripoint &t, int max_range) const
	Uses the map cache to tell if the player could see the given square. More...

tripoint	get_abs_sub () const
	return abs_sub More...

tripoint	getabs (const tripoint &p) const
	Translates local (to this map) coordinates of a square to global absolute coordinates. More...

tripoint_abs_ms	getglobal (const tripoint &p) const

point	getabs (point p) const

tripoint	getlocal (const tripoint &p) const
	Inverse of getabs. More...

tripoint	getlocal (const tripoint_abs_ms &p) const

point	getlocal (point p) const

virtual bool	inbounds (const tripoint &p) const

bool	inbounds (const tripoint_abs_ms &p) const

bool	inbounds (point p) const

bool	inbounds_z (const int z) const

void	clip_to_bounds (tripoint &p) const
	Clips the coordinates of p to fit the map bounds. More...

void	clip_to_bounds (int &x, int &y) const

void	clip_to_bounds (int &x, int &y, int &z) const

int	getmapsize () const

bool	has_zlevels () const

void	rotate (int turns, bool setpos_safe=false)
	Rotates this map, and all of its contents, by the specified multiple of 90 degrees. More...

void	spawn_monsters (bool ignore_sight)
	Spawn monsters from submap spawn points and from the overmap. More...

void	rotten_item_spawn (const item &item, const tripoint &p)
	Checks to see if the item that is rotting away generates a creature when it does. More...

void	build_outside_cache (int zlev)

bool	build_floor_cache (int zlev)

void	build_floor_caches ()

void	update_suspension_cache (const int &z)

bash_results	bash_items (const tripoint &p, const bash_params &params)

bash_results	bash_field (const tripoint &p, const bash_params &params)

bash_results	bash_ter_success (const tripoint &p, const bash_params &params)

bash_results	bash_furn_success (const tripoint &p, const bash_params &params)

void	process_items ()

const level_cache &	get_cache_ref (int zlev) const

const pathfinding_cache &	get_pathfinding_cache_ref (int zlev) const

void	update_pathfinding_cache (int zlev) const

void	update_visibility_cache (int zlev)

const visibility_variables &	get_visibility_variables_cache () const

void	update_submap_active_item_status (const tripoint &p)

const std::set< tripoint > &	get_submaps_with_active_items () const

tripoint_range< tripoint >	points_in_rectangle (const tripoint &from, const tripoint &to) const

tripoint_range< tripoint >	points_in_radius (const tripoint &center, size_t radius, size_t radiusz=0) const

tripoint_range< tripoint >	points_on_zlevel () const
	Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub). More...

tripoint_range< tripoint >	points_on_zlevel (int z) const
	Same as above, but uses the specific z-level. More...

std::list< item_location >	get_active_items_in_radius (const tripoint &center, int radius) const

std::list< item_location >	get_active_items_in_radius (const tripoint &center, int radius, special_item_type type) const

std::list< tripoint >	find_furnitures_with_flag_in_radius (const tripoint &center, size_t radius, const std::string &flag, size_t radiusz=0)
	returns positions of furnitures with matching flag in the specified radius More...

std::list< tripoint >	find_furnitures_or_vparts_with_flag_in_radius (const tripoint &center, size_t radius, const std::string &flag, size_t radiusz=0)
	returns positions of furnitures or vehicle parts with matching flag in the specified radius More...

std::list< Creature * >	get_creatures_in_radius (const tripoint &center, size_t radius, size_t radiusz=0)
	returns creatures in specified radius More...

level_cache &	access_cache (int zlev)

const level_cache &	access_cache (int zlev) const

bool	dont_draw_lower_floor (const tripoint &p)

void	support_dirty (const tripoint &p)

void	spawn_monsters_submap (const tripoint &gp, bool ignore_sight)

void	spawn_monsters_submap_group (const tripoint &gp, mongroup &group, bool ignore_sight)

field &	get_field (const tripoint &p)

submap *	getsubmap (size_t grididx) const
	Get the submap pointer with given index in grid, the index must be valid! More...

submap *	get_submap_at (const tripoint &p) const
	Get the submap pointer containing the specified position within the reality bubble. More...

submap *	get_submap_at (point p) const

submap *	get_submap_at (const tripoint &p, point &offset_p) const
	Get the submap pointer containing the specified position within the reality bubble. More...

submap *	get_submap_at (point p, point &offset_p) const

submap *	get_submap_at_grid (point gridp) const
	Get submap pointer in the grid at given grid coordinates. More...

submap *	get_submap_at_grid (const tripoint &gridp) const

int	calc_max_populated_zlev ()
	Caclulate the greatest populated zlevel in the loaded submaps and save in the level cache. More...

void	invalidate_max_populated_zlev (int zlev)
	Conditionally invalidates max_pupulated_zlev cache if the submap uniformity change occurs above current max_pupulated_zlev value. More...

int	move_cost_internal (const furn_t &furniture, const ter_t &terrain, const vehicle *veh, int vpart) const
	Internal versions of public functions to avoid checking same variables multiple times. More...

int	bash_rating_internal (int str, const furn_t &furniture, const ter_t &terrain, bool allow_floor, const vehicle *veh, int part) const

bool	draw_maptile (const catacurses::window &w, const tripoint &p, const maptile &tile, const drawsq_params &params) const
	Internal version of the drawsq. More...

void	draw_from_above (const catacurses::window &w, const tripoint &p, const maptile &tile, const drawsq_params &params) const
	Draws the tile as seen from above. More...

int	determine_wall_corner (const tripoint &p) const

void	apply_light_source (const tripoint &p, float luminance)

void	add_light_source (const tripoint &p, float luminance)

void	apply_directional_light (const tripoint &p, int direction, float luminance)

void	apply_light_arc (const tripoint &p, units::angle, float luminance, units::angle wideangle=30_degrees)

void	apply_light_ray (bool lit[MAPSIZE_X][MAPSIZE_Y], const tripoint &s, const tripoint &e, float luminance)

void	add_light_from_items (const tripoint &p, item_stack::iterator begin, item_stack::iterator end)

std::unique_ptr< vehicle >	add_vehicle_to_map (std::unique_ptr< vehicle > veh, bool merge_wrecks)
	Takes a vehicle already created with new and attempts to place it on the map, checking for collisions. More...

ter_id	get_roof (const tripoint &p, bool allow_air) const

void	process_items_in_submap (submap &current_submap, const tripoint &gridp)

void	process_items_in_vehicles (submap &current_submap)

void	process_items_in_vehicle (vehicle &cur_veh, submap &current_submap)

template<typename Functor >
void	function_over (const tripoint &start, const tripoint &end, Functor fun) const
	Runs a functor over given submaps over submaps in the area, getting next submap only when the current one "runs out" rather than every time. More...

level_cache &	get_cache (int zlev) const

pathfinding_cache &	get_pathfinding_cache (int zlev) const

void	saven (const tripoint &grid)

void	loadn (const tripoint &grid, bool update_vehicles)

void	loadn (point grid, bool update_vehicles)

void	actualize (const tripoint &grid)
	Fast forward a submap that has just been loading into this map. More...

void	add_roofs (const tripoint &grid)
	Hacks in missing roofs. More...

template<typename Container >
void	remove_rotten_items (Container &items, const tripoint &p, temperature_flag temperature)
	Go through the list of items, update their rotten status and remove items that have rotten away completely. More...

void	fill_funnels (const tripoint &p, const time_point &since)
	Try to fill funnel based items here. More...

void	grow_plant (const tripoint &p)
	Try to grow a harvestable plant to the next stage(s). More...

void	restock_fruits (const tripoint &p, const time_duration &time_since_last_actualize)
	Try to grow fruits on static plants (not planted by the player) More...

void	produce_sap (const tripoint &p, const time_duration &time_since_last_actualize)
	Produce sap on tapped maple trees. More...

void	rad_scorch (const tripoint &p, const time_duration &time_since_last_actualize)
	Radiation-related plant (and fungus?) death. More...

void	decay_cosmetic_fields (const tripoint &p, const time_duration &time_since_last_actualize)

void	player_in_field (player &u)

void	monster_in_field (monster &z)

void	shift_traps (const tripoint &shift)
	As part of the map shifting, this shifts the trap locations stored in traplocs. More...

void	copy_grid (const tripoint &to, const tripoint &from)

void	draw_map (mapgendata &dat)

void	draw_office_tower (mapgendata &dat)

void	draw_lab (mapgendata &dat)

void	draw_temple (mapgendata &dat)

void	draw_mine (mapgendata &dat)

void	draw_anthill (mapgendata &dat)

void	draw_slimepit (mapgendata &dat)

void	draw_triffid (mapgendata &dat)

void	draw_connections (mapgendata &dat)

bool	build_transparency_cache (int zlev)

bool	build_vision_transparency_cache (const Character &player)

void	build_sunlight_cache (int pzlev)

void	generate_lightmap (int zlev)

void	build_seen_cache (const tripoint &origin, int target_z)
	Calculates the Field Of View for the provided map from the given x, y coordinates. More...

void	apply_character_light (Character &p)

void	apply_vision_transparency_cache (const tripoint &center, int target_z, float(&vision_restore_cache)[9], bool(&blocked_restore_cache)[8])

void	restore_vision_transparency_cache (const tripoint &center, int target_z, float(&vision_restore_cache)[9], bool(&blocked_restore_cache)[8])

void	set_abs_sub (const tripoint &p)
	Sets abs_sub, see there. More...

size_t	get_nonant (const tripoint &gridp) const
	Get the index of a submap pointer in the grid given by grid coordinates. More...

size_t	get_nonant (point gridp) const

void	setsubmap (size_t grididx, submap *smap)
	Set the submap pointer in grid at the give index. More...

Detailed Description

Manage and cache data about a part of the map.

Despite the name, this class isn't actually responsible for managing the map as a whole. For that function, see mapbuffer. Instead, this class loads a part of the mapbuffer into a cache, and adds certain temporary information such as lighting calculations to it.

To understand the following descriptions better, you should also read Map Management

The map coordinates always start at (0, 0) for the top-left and end at (map_width-1, map_height-1) for the bottom-right.

The actual map data is stored in submap instances. These instances are managed by mapbuffer. References to the currently active submaps are stored in map::grid: 0 1 2 3 4 5 6 7 8 In this example, the top-right submap would be at grid[2].

When the player moves between submaps, the whole map is shifted, so that if the player moves one submap to the right, (0, 0) now points to a tile one submap to the right from before

Definition at line 383 of file map.h.

Member Enumeration Documentation

◆ iteration_state

enum map::iteration_state

private

Enum used by functors in function_over to control execution.

Enumerator
ITER_CONTINUE
ITER_SKIP_SUBMAP
ITER_SKIP_ZLEVEL
ITER_FINISH

Definition at line 1933 of file map.h.

                             {
            ITER_CONTINUE = 0,  // Keep iterating
            ITER_SKIP_SUBMAP,   // Skip the rest of this submap
            ITER_SKIP_ZLEVEL,   // Skip the rest of this z-level
            ITER_FINISH         // End iteration
        };

Constructor & Destructor Documentation

◆ map() [1/2]

map::map	(	int	mapsize = `MAPSIZE`,
		bool	zlev = `false`
	)

Definition at line 176 of file map.cpp.

{
    my_MAPSIZE = mapsize;
    zlevels = zlev;
    if( zlevels ) {
        grid.resize( static_cast<size_t>( my_MAPSIZE * my_MAPSIZE * OVERMAP_LAYERS ), nullptr );
    } else {
        grid.resize( static_cast<size_t>( my_MAPSIZE * my_MAPSIZE ), nullptr );
    }
 
    for( auto &ptr : caches ) {
        ptr = std::make_unique<level_cache>();
    }
 
    for( auto &ptr : pathfinding_caches ) {
        ptr = std::make_unique<pathfinding_cache>();
    }
 
    dbg( DL::Info ) << "map::map(): my_MAPSIZE: " << my_MAPSIZE << " z-levels enabled:" << zlevels;
    traplocs.resize( trap::count() );
}

References caches, trap::count(), dbg, grid, Info, my_MAPSIZE, OVERMAP_LAYERS, pathfinding_caches, ptr(), traplocs, and zlevels.

Referenced by check_submap_active_item_consistency().

◆ map() [2/2]

map::map ( bool zlev )

inlineexplicit

Definition at line 391 of file map.h.

391: map( MAPSIZE, zlev ) { }

map::map

map(int mapsize=MAPSIZE, bool zlev=false)

Definition: map.cpp:176

MAPSIZE

static constexpr int MAPSIZE

Definition: game_constants.h:30

◆ ~map()

map::~map ( )

virtualdefault

Member Function Documentation

◆ access_cache() [1/2]

level_cache & map::access_cache ( int zlev )

Definition at line 8890 of file map.cpp.

{
    if( zlev >= -OVERMAP_DEPTH && zlev <= OVERMAP_HEIGHT ) {
        return *caches[zlev + OVERMAP_DEPTH];
    }
 
    debugmsg( "access_cache called with invalid z-level: %d", zlev );
    return nullcache;
}

References caches, debugmsg, nullcache, OVERMAP_DEPTH, and OVERMAP_HEIGHT.

Referenced by get_known_connections(), game::place_player_overmap(), process_items(), scent_map::update(), and game::vertical_shift().

◆ access_cache() [2/2]

const level_cache & map::access_cache ( int zlev ) const

Definition at line 8900 of file map.cpp.

{
    if( zlev >= -OVERMAP_DEPTH && zlev <= OVERMAP_HEIGHT ) {
        return *caches[zlev + OVERMAP_DEPTH];
    }
 
    debugmsg( "access_cache called with invalid z-level: %d", zlev );
    return nullcache;
}

References caches, debugmsg, nullcache, OVERMAP_DEPTH, and OVERMAP_HEIGHT.

◆ accessible_items()

bool map::accessible_items ( const tripoint & t ) const

Check whether the player can access the items located .

Certain furniture/terrain may prevent that (e.g. a locked safe).

Definition at line 6696 of file map.cpp.

{
    return !has_flag( "SEALED", t ) || has_flag( "LIQUIDCONT", t );
}

References has_flag().

Referenced by basecamp::form_crafting_inventory(), inventory::form_from_map(), and use_charges().

◆ actualize()

void map::actualize ( const tripoint & grid )

protected

Fast forward a submap that has just been loading into this map.

This is used to rot and remove rotten items, grow plants, fill funnels etc.

Definition at line 7547 of file map.cpp.

{
    submap *const tmpsub = get_submap_at_grid( grid );
    if( tmpsub == nullptr ) {
        debugmsg( "Actualize called on null submap (%d,%d,%d)", grid.x, grid.y, grid.z );
        return;
    }
 
    const time_duration time_since_last_actualize = calendar::turn - tmpsub->last_touched;
    const bool do_funnels = ( grid.z >= 0 );
 
    // check spoiled stuff, and fill up funnels while we're at it
    for( int x = 0; x < SEEX; x++ ) {
        for( int y = 0; y < SEEY; y++ ) {
            const tripoint pnt = sm_to_ms_copy( grid ) + point( x, y );
            const point p( x, y );
            const auto &furn = this->furn( pnt ).obj();
            if( furn.has_flag( "EMITTER" ) ) {
                field_furn_locs.push_back( pnt );
            }
            // plants contain a seed item which must not be removed under any circumstances
            if( !furn.has_flag( "DONT_REMOVE_ROTTEN" ) ) {
                temperature_flag temperature = temperature_flag_at_point( *this, pnt );
                remove_rotten_items( tmpsub->get_items( { x, y } ), pnt, temperature );
            }
 
            const auto trap_here = tmpsub->get_trap( p );
            if( trap_here != tr_null ) {
                traplocs[trap_here.to_i()].push_back( pnt );
            }
            const ter_t &ter = tmpsub->get_ter( p ).obj();
            if( ter.trap != tr_null && ter.trap != tr_ledge ) {
                traplocs[ter.trap.to_i()].push_back( pnt );
            }
 
            if( do_funnels ) {
                fill_funnels( pnt, tmpsub->last_touched );
            }
 
            grow_plant( pnt );
 
            restock_fruits( pnt, time_since_last_actualize );
 
            produce_sap( pnt, time_since_last_actualize );
 
            rad_scorch( pnt, time_since_last_actualize );
 
            decay_cosmetic_fields( pnt, time_since_last_actualize );
        }
    }
 
    // the last time we touched the submap, is right now.
    tmpsub->last_touched = calendar::turn;
}

References debugmsg, decay_cosmetic_fields(), field_furn_locs, fill_funnels(), furn(), submap::get_items(), get_submap_at_grid(), submap::get_ter(), submap::get_trap(), grid, grow_plant(), submap::last_touched, int_id< T >::obj(), produce_sap(), rad_scorch(), remove_rotten_items(), restock_fruits(), SEEX, SEEY, sm_to_ms_copy(), temperature_flag_at_point(), ter(), int_id< T >::to_i(), tr_ledge, tr_null, traplocs, and calendar::turn.

Referenced by loadn().

◆ add_camp()

void map::add_camp	(	const tripoint_abs_omt &	omt_pos,
		const std::string &	name
	)

Definition at line 5719 of file map.cpp.

{
    basecamp temp_camp = basecamp( name, omt_pos );
    overmap_buffer.add_camp( temp_camp );
    g->u.camps.insert( omt_pos );
    g->validate_camps();
}

References overmapbuffer::add_camp(), g, name(), and overmap_buffer.

Referenced by get_basecamp().

◆ add_computer()

computer * map::add_computer	(	const tripoint &	p,
		const std::string &	name,
		int	security
	)

Definition at line 5621 of file mapgen.cpp.

{
    // TODO: Turn this off?
    ter_set( p, t_console );
    point l;
    submap *const place_on_submap = get_submap_at( p, l );
    place_on_submap->set_computer( l, computer( name, security ) );
    return place_on_submap->get_computer( l );
}

References submap::get_computer(), get_submap_at(), name(), submap::set_computer(), t_console, and ter_set().

Referenced by jmapgen_computer::apply(), create_lab_consoles(), mission_start::place_npc_software(), and science_room().

◆ add_corpse()

void map::add_corpse ( const tripoint & p )

Definition at line 8603 of file map.cpp.

{
    item body;
 
    const bool isReviveSpecial = one_in( 10 );
 
    if( !isReviveSpecial ) {
        body = item::make_corpse();
    } else {
        body = item::make_corpse( mon_zombie );
        body.set_flag( "REVIVE_SPECIAL" );
    }
 
    put_items_from_loc( item_group_id( "default_zombie_clothes" ), p );
    if( one_in( 3 ) ) {
        put_items_from_loc( item_group_id( "default_zombie_items" ), p );
    }
 
    add_item_or_charges( p, body );
}

References add_item_or_charges(), item::make_corpse(), mon_zombie, one_in(), put_items_from_loc(), and item::set_flag().

Referenced by add_corpse(), MapExtras::mx_looters(), MapExtras::mx_mayhem(), and MapExtras::mx_minefield().

◆ add_field()

bool map::add_field	(	const tripoint &	p,
		const field_type_id &	type_id,
		int	intensity = `INT_MAX`,
		const time_duration &	age = `0_turns`,
		bool	hit_player = `true`
	)

Add field entry at point, or set intensity if present.

Returns: false if the field could not be created (out of bounds), otherwise true.

Definition at line 5536 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
 
    if( !type_id ) {
        debugmsg( "Tried to add null field" );
        return false;
    }
 
    const field_type &fd_type = *type_id;
    intensity = std::min( intensity, fd_type.get_max_intensity() );
    if( intensity <= 0 ) {
        return false;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
    current_submap->is_uniform = false;
    invalidate_max_populated_zlev( p.z );
 
    if( current_submap->get_field( l ).add_field( type_id, intensity, age ) ) {
        //Only adding it to the count if it doesn't exist.
        if( !current_submap->field_count++ ) {
            get_cache( p.z ).field_cache.set( static_cast<size_t>( p.x / SEEX + ( (
                                                  p.y / SEEX ) * MAPSIZE ) ) );
        }
    }
 
    if( hit_player ) {
        Character &player_character = get_player_character();
        if( g != nullptr && this == &get_map() && p == player_character.pos() ) {
            //Hit the player with the field if it spawned on top of them.
            creature_in_field( player_character );
        }
    }
 
    // Dirty the transparency cache now that field processing doesn't always do it
    if( fd_type.dirty_transparency_cache || !fd_type.is_transparent() ) {
        set_transparency_cache_dirty( p );
        set_seen_cache_dirty( p );
    }
 
    if( fd_type.is_dangerous() ) {
        set_pathfinding_cache_dirty( p.z );
    }
 
    // Ensure blood type fields don't hang in the air
    if( zlevels && fd_type.accelerated_decay ) {
        support_dirty( p );
    }
 
    return true;
}

References field_type::accelerated_decay, field::add_field(), creature_in_field(), debugmsg, field_type::dirty_transparency_cache, level_cache::field_cache, submap::field_count, g, get_cache(), submap::get_field(), get_map(), field_type::get_max_intensity(), get_player_character(), get_submap_at(), inbounds(), invalidate_max_populated_zlev(), field_type::is_dangerous(), field_type::is_transparent(), submap::is_uniform, MAPSIZE, Character::pos(), SEEX, set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_transparency_cache_dirty(), support_dirty(), tripoint::x, tripoint::y, tripoint::z, and zlevels.

Referenced by jmapgen_field::apply(), start_location::burn(), create_anomaly(), create_hot_air(), draw_lab(), draw_mine(), draw_temple(), draw_triffid(), drop_fields(), gas_spread_to(), hit_with_fire(), madd_field(), MapExtras::mx_casings(), MapExtras::mx_corpses(), MapExtras::mx_drugdeal(), MapExtras::mx_looters(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), MapExtras::mx_portal_in(), MapExtras::mx_roadblock(), MapExtras::mx_spider(), game::process_artifact(), process_fields_in_submap(), set_field_intensity(), and shoot().

◆ add_item() [1/2]

item & map::add_item	(	const tripoint &	p,
		item	new_item
	)

Place an item on the map, despite the parameter name, this is not necessarily a new item.

WARNING: does -not- check volume or stack charges. player functions (drop etc) should use map::add_item_or_charges

Returns: The item that got added, or nulitem.

Definition at line 4455 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return null_item_reference();
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    // Process foods when they are added to the map, here instead of add_item_at()
    // to avoid double processing food and corpses during active item processing.
    if( new_item.is_food() ) {
        new_item.process( nullptr, p, false );
    }
 
    if( new_item.made_of( LIQUID ) && has_flag( "SWIMMABLE", p ) ) {
        return null_item_reference();
    }
 
    if( has_flag( "DESTROY_ITEM", p ) ) {
        return null_item_reference();
    }
 
    if( new_item.has_flag( "ACT_IN_FIRE" ) && get_field( p, fd_fire ) != nullptr ) {
        if( new_item.has_flag( "BOMB" ) && new_item.is_transformable() ) {
            //Convert a bomb item into its transformable version, e.g. incendiary grenade -> active incendiary grenade
            new_item.convert( dynamic_cast<const iuse_transform *>
                              ( new_item.type->get_use( "transform" )->get_actor_ptr() )->target );
        }
        new_item.active = true;
    }
 
    if( new_item.is_map() && !new_item.has_var( "reveal_map_center_omt" ) ) {
        new_item.set_var( "reveal_map_center_omt", ms_to_omt_copy( getabs( p ) ) );
    }
 
    current_submap->is_uniform = false;
    invalidate_max_populated_zlev( p.z );
 
    current_submap->update_lum_add( l, new_item );
 
    const map_stack::iterator new_pos = current_submap->get_items( l ).insert( new_item );
    if( new_item.needs_processing() ) {
        if( current_submap->active_items.empty() ) {
            submaps_with_active_items.insert( tripoint( abs_sub.x + p.x / SEEX, abs_sub.y + p.y / SEEY, p.z ) );
        }
        current_submap->active_items.add( *new_pos, l );
    }
 
    return *new_pos;
}

References abs_sub, item::active, submap::active_items, active_item_cache::add(), item::convert(), active_item_cache::empty(), fd_fire, use_function::get_actor_ptr(), get_field(), submap::get_items(), get_submap_at(), itype::get_use(), getabs(), item::has_flag(), has_flag(), item::has_var(), inbounds(), invalidate_max_populated_zlev(), item::is_food(), item::is_map(), item::is_transformable(), submap::is_uniform, LIQUID, item::made_of(), ms_to_omt_copy(), item::needs_processing(), null_item_reference(), item::process(), SEEX, SEEY, item::set_var(), submaps_with_active_items, iuse_transform::target, item::type, submap::update_lum_add(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_item(), add_item_or_charges(), item::ammo_consume(), draw_mine(), extract_or_wreck_cbms(), place_gas_pump(), place_toilet(), and Character::uninstall_bionic().

◆ add_item() [2/2]

void map::add_item	(	point	p,
		item	new_item
	)

inline

Definition at line 1248 of file map.h.

                                                {
            add_item( tripoint( p, abs_sub.z ), new_item );
        }

References abs_sub, add_item(), and tripoint::z.

◆ add_item_or_charges() [1/2]

item & map::add_item_or_charges	(	const tripoint &	pos,
		item	obj,
		bool	overflow = `true`
	)

Adds an item to map tile or stacks charges.

Parameters

pos	Where to add item
obj	Item to add
overflow	if destination is full attempt to drop on adjacent tiles

Returns: reference to dropped (and possibly stacked) item or null item on failure

Warning: function is relatively expensive and meant for user initiated actions, not mapgen

Definition at line 4355 of file map.cpp.

{
    // Checks if item would not be destroyed if added to this tile
    auto valid_tile = [&]( const tripoint & e ) {
        if( !inbounds( e ) ) {
            // should never happen
            debugmsg( "add_item_or_charges: %s is out of bounds (adding item '%s' [%d])",
                      e.to_string(), obj.typeId().c_str(), obj.charges );
            return false;
        }
 
        // Some tiles destroy items (e.g. lava)
        if( has_flag( "DESTROY_ITEM", e ) ) {
            return false;
        }
 
        // Cannot drop liquids into tiles that are comprised of liquid
        if( obj.made_of( LIQUID ) && has_flag( "SWIMMABLE", e ) ) {
            return false;
        }
 
        return true;
    };
 
    // Checks if sufficient space at tile to add item
    auto valid_limits = [&]( const tripoint & e ) {
        return obj.volume() <= free_volume( e ) && i_at( e ).size() < MAX_ITEM_IN_SQUARE;
    };
 
    // Performs the actual insertion of the object onto the map
    auto place_item = [&]( const tripoint & tile ) -> item& {
        if( obj.count_by_charges() )
        {
            for( auto &e : i_at( tile ) ) {
                if( e.merge_charges( obj ) ) {
                    return e;
                }
            }
        }
 
        support_dirty( tile );
        return add_item( tile, obj );
    };
 
    // Some items never exist on map as a discrete item (must be contained by another item)
    if( obj.has_flag( "NO_DROP" ) ) {
        return null_item_reference();
    }
 
    // If intended drop tile destroys the item then we don't attempt to overflow
    if( !valid_tile( pos ) ) {
        return null_item_reference();
    }
 
    if( ( !has_flag( "NOITEM", pos ) || ( has_flag( "LIQUIDCONT", pos ) && obj.made_of( LIQUID ) ) )
        && valid_limits( pos ) ) {
        // Pass map into on_drop, because this map may not be the global map object (in mapgen, for instance).
        if( obj.made_of( LIQUID ) || !obj.has_flag( "DROP_ACTION_ONLY_IF_LIQUID" ) ) {
            if( obj.on_drop( pos, *this ) ) {
                return null_item_reference();
            }
 
        }
        // If tile can contain items place here...
        return place_item( pos );
 
    } else if( overflow ) {
        // ...otherwise try to overflow to adjacent tiles (if permitted)
        const int max_dist = 2;
        std::vector<tripoint> tiles = closest_points_first( pos, max_dist );
        tiles.erase( tiles.begin() ); // we already tried this position
        const int max_path_length = 4 * max_dist;
        const pathfinding_settings setting( 0, max_dist, max_path_length, 0, false, true, false, false,
                                            false );
        for( const tripoint &e : tiles ) {
            if( !inbounds( e ) ) {
                continue;
            }
            //must be a path to the target tile
            if( route( pos, e, setting ).empty() ) {
                continue;
            }
            if( obj.made_of( LIQUID ) || !obj.has_flag( "DROP_ACTION_ONLY_IF_LIQUID" ) ) {
                if( obj.on_drop( e, *this ) ) {
                    return null_item_reference();
                }
            }
 
            if( !valid_tile( e ) || !valid_limits( e ) ||
                has_flag( "NOITEM", e ) || has_flag( "SEALED", e ) ) {
                continue;
            }
            return place_item( e );
        }
    }
 
    // failed due to lack of space at target tile (+/- overflow tiles)
    return null_item_reference();
}

References add_item(), string_id< T >::c_str(), item::charges, closest_points_first(), item::count_by_charges(), debugmsg, free_volume(), item::has_flag(), has_flag(), i_at(), inbounds(), LIQUID, item::made_of(), MAX_ITEM_IN_SQUARE, null_item_reference(), item::on_drop(), wrapped_vehicle::pos, route(), item_stack::size(), support_dirty(), item::typeId(), and item::volume().

Referenced by add_corpse(), MapgenRemovePartHandler::add_item_or_charges(), add_item_or_charges(), jmapgen_liquid_item::apply(), defense_game::caravan(), game::catch_a_monster(), doors::close_door(), game::disable_robot(), draw_lab(), Character::drop_invalid_inventory(), drop_items(), talk_function::drop_weapon(), farm_action(), talk_function::field_plant(), game::forced_door_closing(), handle_harvest(), pickup::handle_spillable_contents(), map_stack::insert(), make_mon_corpse(), MapExtras::mx_grave(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), om_set_hide_site(), Character::place_corpse(), basecamp::place_results(), talk_function::player_weapon_drop(), process_fields_in_submap(), monexamine::remove_armor(), monexamine::remove_bag_from(), monexamine::remove_battery(), set_item_map(), smash_items(), spawn_an_item(), spawn_artifact(), spawn_items(), spawn_natural_artifact(), item::spill_contents(), and item_contents::spill_contents().

◆ add_item_or_charges() [2/2]

item & map::add_item_or_charges	(	point	p,
		item	obj,
		bool	overflow = `true`
	)

inline

Definition at line 1236 of file map.h.

                                                                             {
            return add_item_or_charges( tripoint( p, abs_sub.z ), obj, overflow );
        }

References abs_sub, add_item_or_charges(), and tripoint::z.

◆ add_light_from_items()

void map::add_light_from_items	(	const tripoint &	p,
		item_stack::iterator	begin,
		item_stack::iterator	end
	)

private

Definition at line 87 of file lightmap.cpp.

{
    for( auto itm_it = begin; itm_it != end; ++itm_it ) {
        float ilum = 0.0f; // brightness
        units::angle iwidth = 0_degrees; // 0-360 degrees. 0 is a circular light_source
        units::angle idir = 0_degrees;   // otherwise, it's a light_arc pointed in this direction
        if( itm_it->getlight( ilum, iwidth, idir ) ) {
            if( iwidth > 0_degrees ) {
                apply_light_arc( p, idir, ilum, iwidth );
            } else {
                add_light_source( p, ilum );
            }
        }
    }
}

References add_light_source(), and apply_light_arc().

Referenced by generate_lightmap().

◆ add_light_source()

void map::add_light_source	(	const tripoint &	p,
		float	luminance
	)

private

Definition at line 649 of file lightmap.cpp.

{
    auto &light_source_buffer = get_cache( p.z ).light_source_buffer;
    light_source_buffer[p.x][p.y] = std::max( luminance, light_source_buffer[p.x][p.y] );
}

References get_cache(), level_cache::light_source_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_light_from_items(), and generate_lightmap().

◆ add_roofs()

void map::add_roofs ( const tripoint & grid )

protected

Hacks in missing roofs.

Should be removed when 3D mapgen is done.

Definition at line 7602 of file map.cpp.

{
    if( !zlevels ) {
        // No roofs required!
        // Why not? Because submaps below and above don't exist yet
        return;
    }
 
    submap *const sub_here = get_submap_at_grid( grid );
    if( sub_here == nullptr ) {
        debugmsg( "Tried to add roofs/floors on null submap on %d,%d,%d",
                  grid.x, grid.y, grid.z );
        return;
    }
 
    bool check_roof = grid.z > -OVERMAP_DEPTH;
 
    submap *const sub_below = check_roof ? get_submap_at_grid( grid + tripoint_below ) : nullptr;
 
    if( check_roof && sub_below == nullptr ) {
        debugmsg( "Tried to add roofs to sm at %d,%d,%d, but sm below doesn't exist",
                  grid.x, grid.y, grid.z );
        return;
    }
 
    for( int x = 0; x < SEEX; x++ ) {
        for( int y = 0; y < SEEY; y++ ) {
            const ter_id ter_here = sub_here->get_ter( { x, y } );
            if( ter_here != t_open_air ) {
                continue;
            }
 
            if( !check_roof ) {
                // Make sure we don't have open air at lowest z-level
                sub_here->set_ter( { x, y }, t_rock_floor );
                continue;
            }
 
            const ter_t &ter_below = sub_below->get_ter( { x, y } ).obj();
            if( ter_below.roof ) {
                // TODO: Make roof variable a ter_id to speed this up
                sub_here->set_ter( { x, y }, ter_below.roof.id() );
            }
        }
    }
}

References debugmsg, get_submap_at_grid(), submap::get_ter(), grid, string_id< T >::id(), OVERMAP_DEPTH, ter_t::roof, SEEX, SEEY, submap::set_ter(), t_open_air, t_rock_floor, tripoint_below, and zlevels.

Referenced by loadn(), and shift().

◆ add_spawn()

void map::add_spawn	(	const mtype_id &	type,
		int	count,
		const tripoint &	p,
		bool	friendly = `false`,
		int	faction_id = `-1`,
		int	mission_id = `-1`,
		const std::string &	name = `"NONE"`
	)		const

Definition at line 5416 of file mapgen.cpp.

{
    if( p.x < 0 || p.x >= SEEX * my_MAPSIZE || p.y < 0 || p.y >= SEEY * my_MAPSIZE ) {
        debugmsg( "Bad add_spawn(%s, %d, %d, %d)", type.c_str(), count, p.x, p.y );
        return;
    }
    point offset;
    submap *place_on_submap = get_submap_at( p, offset );
 
    if( !place_on_submap ) {
        debugmsg( "centadodecamonant doesn't exist in grid; within add_spawn(%s, %d, %d, %d, %d)",
                  type.c_str(), count, p.x, p.y, p.z );
        return;
    }
    if( MonsterGroupManager::monster_is_blacklisted( type ) ) {
        return;
    }
    spawn_point tmp( type, count, offset, faction_id, mission_id, friendly, name );
    place_on_submap->spawns.push_back( tmp );
}

References detail::count(), debugmsg, friendly, get_submap_at(), MonsterGroupManager::monster_is_blacklisted(), my_MAPSIZE, name(), SEEX, SEEY, submap::spawns, type, tripoint::x, tripoint::y, and tripoint::z.

Referenced by jmapgen_monster::apply(), generate(), mission_start::kill_horde_master(), mapgen_ants_larvae(), mapgen_ants_larvae_acid(), mapgen_ants_queen(), mapgen_ants_queen_acid(), mapgen_hive(), mapgen_road(), MapExtras::mx_collegekids(), MapExtras::mx_drugdeal(), MapExtras::mx_helicopter(), MapExtras::mx_house_spider(), MapExtras::mx_house_wasp(), MapExtras::mx_jabberwock(), MapExtras::mx_marloss_pilgrimage(), MapExtras::mx_military(), MapExtras::mx_roadblock(), MapExtras::mx_science(), MapExtras::mx_shia(), MapExtras::mx_spider(), mission_start::place_dog(), place_spawns(), mission_start::place_zombie_mom(), process_fields_in_submap(), and rotten_item_spawn().

◆ add_splash()

void map::add_splash	(	const field_type_id &	type,
		const tripoint &	center,
		int	radius,
		int	intensity
	)

Definition at line 5668 of file map.cpp.

{
    if( !type.id() ) {
        return;
    }
    // TODO: use Bresenham here and take obstacles into account
    for( const tripoint &pnt : points_in_radius( center, radius ) ) {
        if( trig_dist( pnt, center ) <= radius && !one_in( intensity ) ) {
            add_splatter( type, pnt );
        }
    }
}

References add_splatter(), center, one_in(), points_in_radius(), trig_dist(), and type.

Referenced by smash_items().

◆ add_splatter()

void map::add_splatter	(	const field_type_id &	type,
		const tripoint &	where,
		int	intensity = `1`
	)

Definition at line 5619 of file map.cpp.

{
    if( !type.id() || intensity <= 0 ) {
        return;
    }
    if( type.obj().is_splattering ) {
        if( const optional_vpart_position vp = veh_at( where ) ) {
            vehicle *const veh = &vp->vehicle();
            // Might be -1 if all the vehicle's parts at where are marked for removal
            const int part = veh->part_displayed_at( vp->mount() );
            if( part != -1 ) {
                veh->part( part ).blood += 200 * std::min( intensity, 3 ) / 3;
                return;
            }
        }
    }
    mod_field_intensity( where, type, intensity );
}

References vehicle_part::blood, mod_field_intensity(), vehicle::part(), vehicle::part_displayed_at(), type, veh_at(), and vehicle::vehicle().

Referenced by add_splash(), add_splatter_trail(), and Creature::bleed().

◆ add_splatter_trail()

void map::add_splatter_trail	(	const field_type_id &	type,
		const tripoint &	from,
		const tripoint &	to
	)

Definition at line 5638 of file map.cpp.

{
    if( !type.id() ) {
        return;
    }
    auto trail = line_to( from, to );
    int remainder = trail.size();
    tripoint last_point = from;
    for( tripoint &elem : trail ) {
        add_splatter( type, elem );
        remainder--;
        if( obstructed_by_vehicle_rotation( last_point, elem ) ) {
            if( one_in( 2 ) ) {
                elem.x = last_point.x;
                add_splatter( type, elem, remainder );
            } else {
                elem.y = last_point.y;
                add_splatter( type, elem, remainder );
            }
            return;
        }
        if( impassable( elem ) ) { // Blood splatters stop at walls.
            add_splatter( type, elem, remainder );
            return;
        }
        last_point = elem;
    }
}

References add_splatter(), impassable(), line_to(), obstructed_by_vehicle_rotation(), one_in(), type, tripoint::x, and tripoint::y.

Referenced by MapExtras::mx_casings(), MapExtras::mx_mayhem(), and MapExtras::mx_minefield().

◆ add_vehicle() [1/4]

vehicle * map::add_vehicle	(	const vgroup_id &	type,
		const tripoint &	p,
		units::angle	dir,
		int	init_veh_fuel = `-1`,
		int	init_veh_status = `-1`,
		bool	merge_wrecks = `true`
	)

Definition at line 5438 of file mapgen.cpp.

{
    return add_vehicle( type.obj().pick(), p, dir, veh_fuel, veh_status, merge_wrecks );
}

References add_vehicle(), and type.

Referenced by add_vehicle(), VehicleFunction_json::apply(), jmapgen_vehicle::apply(), VehicleSpawnFunction::builtin_jackknifed_semi(), VehicleSpawnFunction::builtin_parkinglot(), VehicleSpawnFunction::builtin_pileup(), debug_menu::debug(), construct::done_vehicle(), draw_office_tower(), MapExtras::mx_helicopter(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), MapExtras::mx_roadblock(), MapExtras::mx_roadworks(), game::place_vehicle_nearby(), mission_start::ranch_scavenger_2(), and unfold_vehicle_iuse::use().

◆ add_vehicle() [2/4]

vehicle * map::add_vehicle	(	const vgroup_id &	type,
		point	p,
		units::angle	dir,
		int	init_veh_fuel = `-1`,
		int	init_veh_status = `-1`,
		bool	merge_wrecks = `true`
	)

Definition at line 5444 of file mapgen.cpp.

{
    return add_vehicle( type.obj().pick(), p, dir, veh_fuel, veh_status, merge_wrecks );
}

References add_vehicle(), and type.

◆ add_vehicle() [3/4]

vehicle * map::add_vehicle	(	const vproto_id &	type,
		const tripoint &	p,
		units::angle	dir,
		int	init_veh_fuel = `-1`,
		int	init_veh_status = `-1`,
		bool	merge_wrecks = `true`
	)

Definition at line 5456 of file mapgen.cpp.

{
    if( !type.is_valid() ) {
        debugmsg( "Nonexistent vehicle type: \"%s\"", type.c_str() );
        return nullptr;
    }
    if( !inbounds( p ) ) {
        dbg( DL::Warn ) << string_format( "Out of bounds add_vehicle t=%s d=%d p=%s",
                                          type, to_degrees( dir ), p.to_string() );
        return nullptr;
    }
 
    // debugmsg("n=%d x=%d y=%d MAPSIZE=%d ^2=%d", nonant, x, y, MAPSIZE, MAPSIZE*MAPSIZE);
    auto veh = std::make_unique<vehicle>( type, veh_fuel, veh_status );
    tripoint p_ms = p;
    veh->sm_pos = ms_to_sm_remain( p_ms );
    veh->pos = p_ms.xy();
    veh->place_spawn_items();
    // for backwards compatibility, we always spawn with a pivot point of (0,0) so
    // that the mount at (0,0) is located at the spawn position.
    veh->set_facing_and_pivot( dir, point_zero, false );
    //debugmsg("adding veh: %d, sm: %d,%d,%d, pos: %d, %d", veh, veh->smx, veh->smy, veh->smz, veh->posx, veh->posy);
    std::unique_ptr<vehicle> placed_vehicle_up =
        add_vehicle_to_map( std::move( veh ), merge_wrecks );
    vehicle *placed_vehicle = placed_vehicle_up.get();
 
    if( placed_vehicle != nullptr ) {
        submap *place_on_submap = get_submap_at_grid( placed_vehicle->sm_pos );
        place_on_submap->vehicles.push_back( std::move( placed_vehicle_up ) );
        place_on_submap->is_uniform = false;
        invalidate_max_populated_zlev( p.z );
 
        auto &ch = get_cache( placed_vehicle->sm_pos.z );
        ch.vehicle_list.insert( placed_vehicle );
        add_vehicle_to_cache( placed_vehicle );
 
        //debugmsg ("grid[%d]->vehicles.size=%d veh.parts.size=%d", nonant, grid[nonant]->vehicles.size(),veh.parts.size());
    }
    return placed_vehicle;
}

References add_vehicle_to_cache(), add_vehicle_to_map(), dbg, debugmsg, get_cache(), get_submap_at_grid(), inbounds(), invalidate_max_populated_zlev(), submap::is_uniform, avatar_action::move(), ms_to_sm_remain(), point_zero, vehicle::sm_pos, string_format(), units::to_degrees(), tripoint::to_string(), type, submap::vehicles, Warn, tripoint::xy(), and tripoint::z.

◆ add_vehicle() [4/4]

vehicle * map::add_vehicle	(	const vproto_id &	type,
		point	p,
		units::angle	dir,
		int	init_veh_fuel = `-1`,
		int	init_veh_status = `-1`,
		bool	merge_wrecks = `true`
	)

Definition at line 5450 of file mapgen.cpp.

{
    return add_vehicle( type, tripoint( p, abs_sub.z ), dir, veh_fuel, veh_status, merge_wrecks );
}

References abs_sub, add_vehicle(), type, and tripoint::z.

◆ add_vehicle_to_cache()

void map::add_vehicle_to_cache ( vehicle * veh )

Definition at line 331 of file map.cpp.

{
    if( veh == nullptr ) {
        debugmsg( "Tried to add null vehicle to cache" );
        return;
    }
 
    // Get parts
    for( const vpart_reference &vpr : veh->get_all_parts() ) {
        if( vpr.part().removed ) {
            continue;
        }
        const tripoint p = veh->global_part_pos3( vpr.part() );
        level_cache &ch = get_cache( p.z );
        ch.veh_in_active_range = true;
        ch.veh_cached_parts[p] = std::make_pair( veh,  static_cast<int>( vpr.part_index() ) );
        if( inbounds( p ) ) {
            ch.veh_exists_at[p.x][p.y] = true;
        }
    }
 
    last_full_vehicle_list_dirty = true;
}

References debugmsg, vehicle::get_all_parts(), get_cache(), vehicle::global_part_pos3(), inbounds(), last_full_vehicle_list_dirty, level_cache::veh_cached_parts, level_cache::veh_exists_at, level_cache::veh_in_active_range, tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_vehicle(), displace_vehicle(), construct::done_vehicle(), loadn(), and reset_vehicle_cache().

◆ add_vehicle_to_map()

std::unique_ptr< vehicle > map::add_vehicle_to_map	(	std::unique_ptr< vehicle >	veh,
		bool	merge_wrecks
	)

private

Takes a vehicle already created with new and attempts to place it on the map, checking for collisions.

If the vehicle can't be placed, returns NULL, otherwise returns a pointer to the placed vehicle, which may not necessarily be the one passed in (if wreckage is created by fusing cars).

Parameters

veh	The vehicle to place on the map.
merge_wrecks	Whether crashed vehicles become part of each other

Returns: The vehicle that was finally placed.

Definition at line 5507 of file mapgen.cpp.

{
    //We only want to check once per square, so loop over all structural parts
    std::vector<int> frame_indices = veh->all_parts_at_location( "structure" );
 
    //Check for boat type vehicles that should be placeable in deep water
    const bool can_float = size( veh->get_avail_parts( "FLOATS" ) ) > 2;
 
    //When hitting a wall, only smash the vehicle once (but walls many times)
    bool needs_smashing = false;
 
    veh->attach();
    veh->refresh_position();
 
    for( std::vector<int>::const_iterator part = frame_indices.begin();
         part != frame_indices.end(); part++ ) {
        const auto p = veh->global_part_pos3( *part );
 
        //Don't spawn anything in water
        if( has_flag_ter( TFLAG_DEEP_WATER, p ) && !can_float ) {
            return nullptr;
        }
 
        // Don't spawn shopping carts on top of another vehicle or other obstacle.
        if( veh->type == vproto_id( "shopping_cart" ) ) {
            if( veh_at( p ) || impassable( p ) ) {
                return nullptr;
            }
        }
 
        //For other vehicles, simulate collisions with (non-shopping cart) stuff
        vehicle *const other_veh = veh_pointer_or_null( veh_at( p ) );
        if( other_veh != nullptr && other_veh->type != vproto_id( "shopping_cart" ) ) {
            if( !merge_wrecks ) {
                return nullptr;
            }
 
            // Hard wreck-merging limit: 200 tiles
            // Merging is slow for big vehicles which lags the mapgen
            if( frame_indices.size() + other_veh->all_parts_at_location( "structure" ).size() > 200 ) {
                return nullptr;
            }
 
            /* There's a vehicle here, so let's fuse them together into wreckage and
             * smash them up. It'll look like a nasty collision has occurred.
             * Trying to do a local->global->local conversion would be a major
             * headache, so instead, let's make another vehicle whose (0, 0) point
             * is the (0, 0) of the existing vehicle, convert the coordinates of both
             * vehicles into global coordinates, find the distance between them and
             * p and then install them that way.
             * Create a vehicle with type "null" so it starts out empty. */
            auto wreckage = std::make_unique<vehicle>();
            wreckage->pos = other_veh->pos;
            wreckage->sm_pos = other_veh->sm_pos;
 
            //Where are we on the global scale?
            const tripoint global_pos = wreckage->global_pos3();
 
            for( const vpart_reference &vpr : veh->get_all_parts() ) {
                const tripoint part_pos = veh->global_part_pos3( vpr.part() ) - global_pos;
                // TODO: change mount points to be tripoint
                wreckage->install_part( part_pos.xy(), vpr.part() );
            }
 
            for( const vpart_reference &vpr : other_veh->get_all_parts() ) {
                const tripoint part_pos = other_veh->global_part_pos3( vpr.part() ) - global_pos;
                wreckage->install_part( part_pos.xy(), vpr.part() );
 
            }
 
            wreckage->name = _( "Wreckage" );
 
            // Now get rid of the old vehicles
            std::unique_ptr<vehicle> old_veh = detach_vehicle( other_veh );
            // Failure has happened here when caches are corrupted due to bugs.
            // Add an assertion to avoid null-pointer dereference later.
            assert( old_veh );
 
            // Try again with the wreckage
            std::unique_ptr<vehicle> new_veh = add_vehicle_to_map( std::move( wreckage ), true );
            if( new_veh != nullptr ) {
                new_veh->smash( *this );
                return new_veh;
            }
 
            // If adding the wreck failed, we want to restore the vehicle we tried to merge with
            add_vehicle_to_map( std::move( old_veh ), false );
            return nullptr;
 
        } else if( impassable( p ) ) {
            if( !merge_wrecks ) {
                return nullptr;
            }
 
            // There's a wall or other obstacle here; destroy it
            destroy( p, true );
 
            // Some weird terrain, don't place the vehicle
            if( impassable( p ) ) {
                return nullptr;
            }
 
            needs_smashing = true;
        }
    }
 
    if( needs_smashing ) {
        veh->smash( *this );
    }
 
    return veh;
}

References _, add_vehicle_to_map(), vehicle::all_parts_at_location(), destroy(), detach_vehicle(), vehicle::get_all_parts(), vehicle::global_part_pos3(), has_flag_ter(), impassable(), avatar_action::move(), vehicle::pos, om_direction::size, vehicle::sm_pos, TFLAG_DEEP_WATER, vehicle::type, veh_at(), veh_pointer_or_null(), and tripoint::xy().

Referenced by add_vehicle(), and add_vehicle_to_map().

◆ adjust_radiation() [1/2]

void map::adjust_radiation	(	const tripoint &	p,
		int	delta
	)

Increment the radiation in the given tile by the given delta (decrement it if delta is negative)

Definition at line 4178 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    int current_radiation = current_submap->get_radiation( l );
    current_submap->set_radiation( l, current_radiation + delta );
}

References submap::get_radiation(), get_submap_at(), inbounds(), and submap::set_radiation().

Referenced by adjust_radiation(), MapExtras::mx_crater(), MapExtras::mx_portal_in(), and process_fields_in_submap().

◆ adjust_radiation() [2/2]

void map::adjust_radiation	(	point	p,
		const int	delta
	)

inline

Definition at line 1164 of file map.h.

                                                          {
            adjust_radiation( tripoint( p, abs_sub.z ), delta );
        }

References abs_sub, adjust_radiation(), and tripoint::z.

◆ ambient_light_at()

float map::ambient_light_at ( const tripoint & p ) const

Definition at line 682 of file lightmap.cpp.

{
    if( !inbounds( p ) ) {
        return 0.0f;
    }
 
    return get_cache_ref( p.z ).lm[p.x][p.y].max();
}

References get_cache_ref(), inbounds(), level_cache::lm, four_quadrants::max(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by apply_character_light(), and game::print_terrain_info().

◆ apparent_light_at()

lit_level map::apparent_light_at	(	const tripoint &	p,
		const visibility_variables &	cache
	)		const

Determine the visible light level for a tile, based on light_at for the tile, vision distance, etc.

Parameters

p	The tile on this map to draw.
cache	Currently cached visibility parameters

Definition at line 765 of file lightmap.cpp.

{
    const int dist = rl_dist( g->u.pos(), p );
 
    // Clairvoyance overrides everything.
    if( dist <= cache.u_clairvoyance ) {
        return lit_level::BRIGHT;
    }
    const auto &map_cache = get_cache_ref( p.z );
    const apparent_light_info a = apparent_light_helper( map_cache, p );
 
    // Unimpaired range is an override to strictly limit vision range based on various conditions,
    // but the player can still see light sources.
    if( dist > g->u.unimpaired_range() ) {
        if( !a.obstructed && map_cache.sm[p.x][p.y] > 0.0 ) {
            return lit_level::BRIGHT_ONLY;
        } else {
            return lit_level::DARK;
        }
    }
    if( a.obstructed ) {
        if( a.apparent_light > LIGHT_AMBIENT_LIT ) {
            if( a.apparent_light > cache.g_light_level ) {
                // This represents too hazy to see detail,
                // but enough light getting through to illuminate.
                return lit_level::BRIGHT_ONLY;
            } else {
                // If it's not brighter than the surroundings, it just ends up shadowy.
                return lit_level::LOW;
            }
        } else {
            return lit_level::BLANK;
        }
    }
    // Then we just search for the light level in descending order.
    if( a.apparent_light > LIGHT_SOURCE_BRIGHT || map_cache.sm[p.x][p.y] > 0.0 ) {
        return lit_level::BRIGHT;
    }
    if( a.apparent_light > LIGHT_AMBIENT_LIT ) {
        return lit_level::LIT;
    }
    if( a.apparent_light >= cache.vision_threshold ) {
        return lit_level::LOW;
    } else {
        return lit_level::BLANK;
    }
}

References a, apparent_light_helper(), BLANK, BRIGHT, BRIGHT_ONLY, DARK, g, visibility_variables::g_light_level, get_cache_ref(), LIGHT_AMBIENT_LIT, LIGHT_SOURCE_BRIGHT, LIT, LOW, rl_dist(), visibility_variables::u_clairvoyance, visibility_variables::vision_threshold, tripoint::x, tripoint::y, and tripoint::z.

Referenced by game::draw_look_around_cursor(), game::print_all_tile_info(), and update_visibility_cache().

◆ apparent_light_helper()

map::apparent_light_info map::apparent_light_helper	(	const level_cache &	map_cache,
		const tripoint &	p
	)

static

Helper function for light claculation; exposed here for map editor.

Definition at line 703 of file lightmap.cpp.

{
    const float vis = std::max( map_cache.seen_cache[p.x][p.y], map_cache.camera_cache[p.x][p.y] );
    const bool obstructed = vis <= LIGHT_TRANSPARENCY_SOLID + 0.1;
 
    auto is_opaque = [&map_cache]( point  p ) {
        return map_cache.transparency_cache[p.x][p.y] <= LIGHT_TRANSPARENCY_SOLID &&
               get_player_character().pos().xy() != p;
    };
 
    const bool p_opaque = is_opaque( p.xy() );
    float apparent_light;
 
    if( p_opaque && vis > 0 ) {
        // This is the complicated case.  We want to check which quadrants the
        // player can see the tile from, and only count light values from those
        // quadrants.
        struct offset_and_quadrants {
            point offset;
            std::array<quadrant, 2> quadrants;
        };
        static constexpr std::array<offset_and_quadrants, 8> adjacent_offsets = {{
                { point_south,      {{ quadrant::SE, quadrant::SW }} },
                { point_north,      {{ quadrant::NE, quadrant::NW }} },
                { point_east,       {{ quadrant::SE, quadrant::NE }} },
                { point_south_east, {{ quadrant::SE, quadrant::SE }} },
                { point_north_east, {{ quadrant::NE, quadrant::NE }} },
                { point_west,       {{ quadrant::SW, quadrant::NW }} },
                { point_south_west, {{ quadrant::SW, quadrant::SW }} },
                { point_north_west, {{ quadrant::NW, quadrant::NW }} },
            }
        };
 
        four_quadrants seen_from( 0 );
        for( const offset_and_quadrants &oq : adjacent_offsets ) {
            const point neighbour = p.xy() + oq.offset;
 
            if( !lightmap_boundaries.contains( neighbour ) ) {
                continue;
            }
            if( is_opaque( neighbour ) ) {
                continue;
            }
            if( map_cache.seen_cache[neighbour.x][neighbour.y] == 0 &&
                map_cache.camera_cache[neighbour.x][neighbour.y] == 0 ) {
                continue;
            }
            // This is a non-opaque visible neighbour, so count visibility from the relevant
            // quadrants
            seen_from[oq.quadrants[0]] = vis;
            seen_from[oq.quadrants[1]] = vis;
        }
        apparent_light = ( seen_from * map_cache.lm[p.x][p.y] ).max();
    } else {
        // This is the simple case, for a non-opaque tile light from all
        // directions is equivalent
        apparent_light = vis * map_cache.lm[p.x][p.y].max();
    }
    return { obstructed, apparent_light };
}

References level_cache::camera_cache, get_player_character(), LIGHT_TRANSPARENCY_SOLID, lightmap_boundaries, level_cache::lm, four_quadrants::max(), NE, NW, point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, Character::pos(), SE, level_cache::seen_cache, SW, level_cache::transparency_cache, point::x, tripoint::x, tripoint::xy(), point::y, and tripoint::y.

Referenced by apparent_light_at(), pl_sees(), and editmap::update_view_with_help().

◆ apply_character_light()

void map::apply_character_light ( Character & p )

protected

Definition at line 263 of file lightmap.cpp.

{
    if( p.has_effect( effect_onfire ) ) {
        apply_light_source( p.pos(), 8 );
    } else if( p.has_effect( effect_haslight ) ) {
        apply_light_source( p.pos(), 4 );
    }
 
    const float held_luminance = p.active_light();
    if( held_luminance > LIGHT_AMBIENT_LOW ) {
        apply_light_source( p.pos(), held_luminance );
    }
 
    if( held_luminance >= 4 && held_luminance > ambient_light_at( p.pos() ) - 0.5f ) {
        p.add_effect( effect_haslight, 1_turns );
    }
}

References Character::active_light(), Creature::add_effect(), ambient_light_at(), apply_light_source(), effect_haslight, effect_onfire, Creature::has_effect(), LIGHT_AMBIENT_LOW, and Character::pos().

Referenced by generate_lightmap().

◆ apply_directional_light()

void map::apply_directional_light	(	const tripoint &	p,
		int	direction,
		float	luminance
	)

private

Definition at line 1831 of file lightmap.cpp.

{
    const point p2( p.xy() );
 
    auto &cache = get_cache( p.z );
    four_quadrants( &lm )[MAPSIZE_X][MAPSIZE_Y] = cache.lm;
    float ( &transparency_cache )[MAPSIZE_X][MAPSIZE_Y] = cache.transparency_cache;
    diagonal_blocks( &blocked_cache )[MAPSIZE_X][MAPSIZE_Y] = cache.vehicle_obscured_cache;
 
    if( direction == 90 ) {
        castLightWithLookup < 1, 0, 0, -1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < -1, 0, 0, -1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    } else if( direction == 0 ) {
        castLightWithLookup < 0, -1, 1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < 0, -1, -1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    } else if( direction == 270 ) {
        castLightWithLookup<1, 0, 0, 1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup>(
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < -1, 0, 0, 1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    } else if( direction == 180 ) {
        castLightWithLookup<0, 1, 1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup>(
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < 0, 1, -1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    }
}

References accumulate_transparency(), castLightWithLookup(), get_cache(), light_calc(), light_check(), light_from_lookup(), MAPSIZE_X, MAPSIZE_Y, update_light_quadrants(), tripoint::xy(), and tripoint::z.

Referenced by generate_lightmap().

◆ apply_faction_ownership()

void map::apply_faction_ownership	(	point	p1,
		point	p2,
		const faction_id &	id
	)

Definition at line 5332 of file mapgen.cpp.

{
    for( const tripoint &p : points_in_rectangle( tripoint( p1, abs_sub.z ), tripoint( p2,
            abs_sub.z ) ) ) {
        auto items = i_at( p.xy() );
        for( item &elem : items ) {
            elem.set_owner( id );
        }
        vehicle *source_veh = veh_pointer_or_null( veh_at( p ) );
        if( source_veh ) {
            if( !source_veh->has_owner() ) {
                source_veh->set_owner( id );
            }
        }
    }
}

References abs_sub, vehicle::has_owner(), i_at(), points_in_rectangle(), vehicle::set_owner(), veh_at(), veh_pointer_or_null(), and tripoint::z.

Referenced by jmapgen_faction::apply().

◆ apply_light_arc()

void map::apply_light_arc	(	const tripoint &	p,
		units::angle	angle,
		float	luminance,
		units::angle	wideangle = `30_degrees`
	)

private

Definition at line 1871 of file lightmap.cpp.

{
    if( luminance <= LIGHT_SOURCE_LOCAL ) {
        return;
    }
 
    bool lit[LIGHTMAP_CACHE_X][LIGHTMAP_CACHE_Y] {};
 
    apply_light_source( p, LIGHT_SOURCE_LOCAL );
 
    // Normalize (should work with negative values too)
    const units::angle wangle = wideangle / 2.0;
 
    units::angle nangle = fmod( angle, 360_degrees );
 
    tripoint end;
    int range = LIGHT_RANGE( luminance );
    calc_ray_end( nangle, range, p, end );
    apply_light_ray( lit, p, end, luminance );
 
    tripoint test;
    calc_ray_end( wangle + nangle, range, p, test );
 
    const float wdist = hypot( end.x - test.x, end.y - test.y );
    if( wdist <= 0.5 ) {
        return;
    }
 
    // attempt to determine beam intensity required to cover all squares
    const units::angle wstep = ( wangle / ( wdist * M_SQRT2 ) );
 
    // NOLINTNEXTLINE(clang-analyzer-security.FloatLoopCounter)
    for( units::angle ao = wstep; ao <= wangle; ao += wstep ) {
        if( trigdist ) {
            double fdist = ( ao * M_PI_2 ) / wangle;
            end.x = static_cast<int>(
                        p.x + ( static_cast<double>( range ) - fdist * 2.0 ) * cos( nangle + ao ) );
            end.y = static_cast<int>(
                        p.y + ( static_cast<double>( range ) - fdist * 2.0 ) * sin( nangle + ao ) );
            apply_light_ray( lit, p, end, luminance );
 
            end.x = static_cast<int>(
                        p.x + ( static_cast<double>( range ) - fdist * 2.0 ) * cos( nangle - ao ) );
            end.y = static_cast<int>(
                        p.y + ( static_cast<double>( range ) - fdist * 2.0 ) * sin( nangle - ao ) );
            apply_light_ray( lit, p, end, luminance );
        } else {
            calc_ray_end( nangle + ao, range, p, end );
            apply_light_ray( lit, p, end, luminance );
            calc_ray_end( nangle - ao, range, p, end );
            apply_light_ray( lit, p, end, luminance );
        }
    }
}

References apply_light_ray(), apply_light_source(), calc_ray_end(), units::cos(), units::fmod(), LIGHT_RANGE, LIGHT_SOURCE_LOCAL, LIGHTMAP_CACHE_X, LIGHTMAP_CACHE_Y, M_PI_2, M_SQRT2, range, units::sin(), trigdist, tripoint::x, and tripoint::y.

Referenced by add_light_from_items(), and generate_lightmap().

◆ apply_light_ray()

void map::apply_light_ray	(	bool	lit[MAPSIZE_X][MAPSIZE_Y],
		const tripoint &	s,
		const tripoint &	e,
		float	luminance
	)

private

Definition at line 1927 of file lightmap.cpp.

{
    point a( std::abs( e.x - s.x ) * 2, std::abs( e.y - s.y ) * 2 );
    point d( ( s.x < e.x ) ? 1 : -1, ( s.y < e.y ) ? 1 : -1 );
    point p( s.xy() );
 
    quadrant quad = quadrant_from_x_y( d.x, d.y );
 
    // TODO: Invert that z comparison when it's sane
    if( s.z != e.z || ( s.x == e.x && s.y == e.y ) ) {
        return;
    }
 
    auto &lm = get_cache( s.z ).lm;
    auto &transparency_cache = get_cache( s.z ).transparency_cache;
 
    float distance = 1.0;
    float transparency = LIGHT_TRANSPARENCY_OPEN_AIR;
    const float scaling_factor = static_cast<float>( rl_dist( s, e ) ) /
                                 static_cast<float>( square_dist( s, e ) );
    // TODO: [lightmap] Pull out the common code here rather than duplication
    if( a.x > a.y ) {
        int t = a.y - ( a.x / 2 );
        do {
            if( t >= 0 ) {
                p.y += d.y;
                t -= a.x;
            }
 
            p.x += d.x;
            t += a.y;
 
            // TODO: clamp coordinates to map bounds before this method is called.
            if( lightmap_boundaries.contains( p ) ) {
                float current_transparency = transparency_cache[p.x][p.y];
                bool is_opaque = ( current_transparency == LIGHT_TRANSPARENCY_SOLID );
                if( !lit[p.x][p.y] ) {
                    // Multiple rays will pass through the same squares so we need to record that
                    lit[p.x][p.y] = true;
                    float lm_val = luminance / ( fastexp( transparency * distance ) * distance );
                    quadrant q = is_opaque ? quad : quadrant::default_;
                    lm[p.x][p.y][q] = std::max( lm[p.x][p.y][q], lm_val );
                }
                if( is_opaque ) {
                    break;
                }
                // Cumulative average of the transparency values encountered.
                transparency = ( ( distance - 1.0 ) * transparency + current_transparency ) / distance;
            } else {
                break;
            }
 
            distance += scaling_factor;
        } while( !( p.x == e.x && p.y == e.y ) );
    } else {
        int t = a.x - ( a.y / 2 );
        do {
            if( t >= 0 ) {
                p.x += d.x;
                t -= a.y;
            }
 
            p.y += d.y;
            t += a.x;
 
            if( lightmap_boundaries.contains( p ) ) {
                float current_transparency = transparency_cache[p.x][p.y];
                bool is_opaque = ( current_transparency == LIGHT_TRANSPARENCY_SOLID );
                if( !lit[p.x][p.y] ) {
                    // Multiple rays will pass through the same squares so we need to record that
                    lit[p.x][p.y] = true;
                    float lm_val = luminance / ( fastexp( transparency * distance ) * distance );
                    quadrant q = is_opaque ? quad : quadrant::default_;
                    lm[p.x][p.y][q] = std::max( lm[p.x][p.y][q], lm_val );
                }
                if( is_opaque ) {
                    break;
                }
                // Cumulative average of the transparency values encountered.
                transparency = ( ( distance - 1.0 ) * transparency + current_transparency ) / distance;
            } else {
                break;
            }
 
            distance += scaling_factor;
        } while( !( p.x == e.x && p.y == e.y ) );
    }
}

References a, default_, fastexp(), get_cache(), LIGHT_TRANSPARENCY_OPEN_AIR, LIGHT_TRANSPARENCY_SOLID, lightmap_boundaries, level_cache::lm, quadrant_from_x_y(), rl_dist(), square_dist(), level_cache::transparency_cache, point::x, tripoint::x, tripoint::xy(), point::y, tripoint::y, and tripoint::z.

Referenced by apply_light_arc().

◆ apply_light_source()

void map::apply_light_source	(	const tripoint &	p,
		float	luminance
	)

private

Definition at line 1750 of file lightmap.cpp.

{
    auto &cache = get_cache( p.z );
    four_quadrants( &lm )[MAPSIZE_X][MAPSIZE_Y] = cache.lm;
    float ( &sm )[MAPSIZE_X][MAPSIZE_Y] = cache.sm;
    float ( &transparency_cache )[MAPSIZE_X][MAPSIZE_Y] = cache.transparency_cache;
    float ( &light_source_buffer )[MAPSIZE_X][MAPSIZE_Y] = cache.light_source_buffer;
    diagonal_blocks( &blocked_cache )[MAPSIZE_X][MAPSIZE_Y] = cache.vehicle_obscured_cache;
 
    const point p2( p.xy() );
 
    if( inbounds( p ) ) {
        const float min_light = std::max( static_cast<float>( lit_level::LOW ), luminance );
        lm[p2.x][p2.y] = elementwise_max( lm[p2.x][p2.y], min_light );
        sm[p2.x][p2.y] = std::max( sm[p2.x][p2.y], luminance );
    }
    if( luminance <= lit_level::LOW ) {
        return;
    } else if( luminance <= lit_level::BRIGHT_ONLY ) {
        luminance = 1.49f;
    }
 
    /* If we're a 5 luminance fire , we skip casting rays into ey && sx if we have
         neighboring fires to the north and west that were applied via light_source_buffer
       If there's a 1 luminance candle east in buffer, we still cast rays into ex since it's smaller
       If there's a 100 luminance magnesium flare south added via apply_light_source instead od
         add_light_source, it's unbuffered so we'll still cast rays into sy.
 
          ey
        nnnNnnn
        w     e
        w  5 +e
     sx W 5*1+E ex
        w ++++e
        w+++++e
        sssSsss
           sy
    */
    const int peer_inbounds = LIGHTMAP_CACHE_X - 1;
    bool north = ( p2.y != 0 && light_source_buffer[p2.x][p2.y - 1] < luminance );
    bool south = ( p2.y != peer_inbounds && light_source_buffer[p2.x][p2.y + 1] < luminance );
    bool east = ( p2.x != peer_inbounds && light_source_buffer[p2.x + 1][p2.y] < luminance );
    bool west = ( p2.x != 0 && light_source_buffer[p2.x - 1][p2.y] < luminance );
 
    if( north ) {
        castLightWithLookup < 1, 0, 0, -1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < -1, 0, 0, -1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    }
 
    if( east ) {
        castLightWithLookup < 0, -1, 1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < 0, -1, -1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    }
 
    if( south ) {
        castLightWithLookup<1, 0, 0, 1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup>(
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < -1, 0, 0, 1, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    }
 
    if( west ) {
        castLightWithLookup<0, 1, 1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup>(
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
        castLightWithLookup < 0, 1, -1, 0, float, four_quadrants, light_calc, light_check,
                            update_light_quadrants, accumulate_transparency, light_from_lookup > (
                                lm, transparency_cache, blocked_cache, p2, 0, luminance );
    }
}

References accumulate_transparency(), BRIGHT_ONLY, castLightWithLookup(), get_cache(), inbounds(), light_calc(), light_check(), light_from_lookup(), LIGHTMAP_CACHE_X, LOW, MAPSIZE_X, MAPSIZE_Y, coords::sm, update_light_quadrants(), point::x, tripoint::xy(), point::y, and tripoint::z.

Referenced by apply_character_light(), apply_light_arc(), and generate_lightmap().

◆ apply_vision_transparency_cache()

void map::apply_vision_transparency_cache	(	const tripoint &	center,
		int	target_z,
		float(&)	vision_restore_cache[9],
		bool(&)	blocked_restore_cache[8]
	)

protected

Definition at line 1467 of file lightmap.cpp.

{
    level_cache &map_cache = get_cache( target_z );
    float ( &transparency_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.transparency_cache;
    diagonal_blocks( &blocked_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.vehicle_obscured_cache;
 
    int i = 0;
    for( point adjacent : eight_adjacent_offsets ) {
        const tripoint p = center + adjacent;
        if( !inbounds( p ) ) {
            continue;
        }
        vision_restore_cache[i] = transparency_cache[p.x][p.y];
        if( vision_transparency_cache[i] == VISION_ADJUST_SOLID ) {
            transparency_cache[p.x][p.y] = LIGHT_TRANSPARENCY_SOLID;
        } else if( vision_transparency_cache[i] == VISION_ADJUST_HIDDEN ) {
 
            if( std::find( four_diagonal_offsets.begin(), four_diagonal_offsets.end(),
                           adjacent ) == four_diagonal_offsets.end() ) {
                debugmsg( "Hidden tile not on a diagonal" );
                continue;
            }
 
            bool &relevant_blocked = adjacent == point_north_east ? blocked_cache[center.x][center.y].ne :
                                     adjacent == point_south_east ? blocked_cache[p.x][p.y].nw :
                                     adjacent == point_south_west ? blocked_cache[p.x][p.y].ne :
                                     /* point_north_west */ blocked_cache[center.x][center.y].nw;
 
            //We only set the restore cache if we actually flip the bit
            blocked_restore_cache[i] = !relevant_blocked;
 
            relevant_blocked = true;
        }
        i++;
    }
    vision_restore_cache[8] = transparency_cache[center.x][center.y];
}

References center, debugmsg, eight_adjacent_offsets, detail::find(), four_diagonal_offsets, get_cache(), inbounds(), LIGHT_TRANSPARENCY_SOLID, MAPSIZE_X, MAPSIZE_Y, point_north_east, point_south_east, point_south_west, level_cache::transparency_cache, level_cache::vehicle_obscured_cache, VISION_ADJUST_HIDDEN, VISION_ADJUST_SOLID, vision_transparency_cache, tripoint::x, and tripoint::y.

Referenced by build_seen_cache().

◆ bash()

bash_results map::bash	(	const tripoint &	p,
		int	str,
		bool	silent = `false`,
		bool	destroy = `false`,
		bool	bash_floor = `false`,
		const vehicle *	bashing_vehicle = `nullptr`
	)

Returns a pair where first is whether anything was smashed and second is if it was destroyed.

Parameters

p	Where to bash
str	How hard to bash
silent	Don't produce any sound
destroy	Destroys some otherwise unbashable tiles
bash_floor	Allow bashing the floor and the tile that supports it
bashing_vehicle	Vehicle that should NOT be bashed (because it is doing the bashing)

Definition at line 3624 of file map.cpp.

{
    bash_params bsh{
        str, silent, destroy, bash_floor, static_cast<float>( rng_float( 0, 1.0f ) ), false, true
    };
    bash_results result;
    if( !inbounds( p ) ) {
        return result;
    }
 
    bool bashed_sealed = false;
    if( has_flag( "SEALED", p ) ) {
        result |= bash_ter_furn( p, bsh );
        bashed_sealed = true;
    }
 
    result |= bash_field( p, bsh );
 
    // Don't bash items inside terrain/furniture with SEALED flag
    if( !bashed_sealed ) {
        result |= bash_items( p, bsh );
    }
    // Don't bash the vehicle doing the bashing
    const vehicle *veh = veh_pointer_or_null( veh_at( p ) );
    if( veh != nullptr && veh != bashing_vehicle ) {
        result |= bash_vehicle( p, bsh );
    }
 
    // If we still didn't bash anything solid (a vehicle) or a tile with SEALED flag, bash ter/furn
    if( !result.bashed_solid && !bashed_sealed ) {
        result |= bash_ter_furn( p, bsh );
    }
 
    return result;
}

References bash_field(), bash_items(), bash_ter_furn(), bash_vehicle(), destroy(), has_flag(), inbounds(), rng_float(), silent, veh_at(), and veh_pointer_or_null().

Referenced by jmapgen_setmap::apply(), spell_effect::bash(), bash_furn_success(), bash_resistance(), bash_strength(), bash_ter_furn(), bash_ter_success(), batter(), destroy(), destroy_furn(), drop_furniture(), drop_items(), game::fling_creature(), is_bashable(), game::knockback(), route(), shoot(), and valid_move().

◆ bash_field()

bash_results map::bash_field	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3714 of file map.cpp.

{
    bash_results result;
    if( get_field( p, fd_web ) != nullptr ) {
        result.did_bash = true;
        result.bashed_solid = true; // To prevent bashing furniture/vehicles
        remove_field( p, fd_web );
    }
 
    return result;
}

References fd_web, get_field(), and remove_field().

Referenced by bash().

◆ bash_furn_success()

bash_results map::bash_furn_success	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3400 of file map.cpp.

{
    bash_results result;
    const auto &furnid = furn( p ).obj();
    const map_bash_info &bash = furnid.bash;
 
 
    if( has_flag_furn( "FUNGUS", p ) ) {
        fungal_effects( *g, *this ).create_spores( p );
    }
    if( has_flag_furn( "MIGO_NERVE", p ) ) {
        map_funcs::migo_nerve_cage_removal( *this, p, true );
    }
    std::string soundfxvariant = furnid.id.str();
    const bool tent = !bash.tent_centers.empty();
 
    // Special code to collapse the tent if destroyed
    if( tent ) {
        // Get ids of possible centers
        std::set<furn_id> centers;
        for( const auto &cur_id : bash.tent_centers ) {
            if( cur_id.is_valid() ) {
                centers.insert( cur_id );
            }
        }
 
        std::optional<std::pair<tripoint, furn_id>> tentp;
 
        // Find the center of the tent
        // First check if we're not currently bashing the center
        if( centers.count( furn( p ) ) > 0 ) {
            tentp.emplace( p, furn( p ) );
        } else {
            for( const tripoint &pt : points_in_radius( p, bash.collapse_radius ) ) {
                const furn_id &f_at = furn( pt );
                // Check if we found the center of the current tent
                if( centers.count( f_at ) > 0 ) {
                    tentp.emplace( pt, f_at );
                    break;
                }
            }
        }
        // Didn't find any tent center, wreck the current tile
        if( !tentp ) {
            spawn_items( p, item_group::items_from( bash.drop_group, calendar::turn ) );
            furn_set( p, bash.furn_set );
        } else {
            // Take the tent down
            const int rad = tentp->second.obj().bash.collapse_radius;
            for( const tripoint &pt : points_in_radius( tentp->first, rad ) ) {
                const furn_id frn = furn( pt );
                if( frn == f_null ) {
                    continue;
                }
 
                const map_bash_info &recur_bash = frn.obj().bash;
                // Check if we share a center type and thus a "tent type"
                for( const auto &cur_id : recur_bash.tent_centers ) {
                    if( centers.count( cur_id.id() ) > 0 ) {
                        // Found same center, wreck current tile
                        spawn_items( p, item_group::items_from( recur_bash.drop_group, calendar::turn ) );
                        furn_set( pt, recur_bash.furn_set );
                        break;
                    }
                }
            }
        }
        soundfxvariant = "smash_cloth";
    } else {
        furn_set( p, bash.furn_set );
        for( item &it : i_at( p ) )  {
            it.on_drop( p, *this );
        }
        // HACK: Hack alert.
        // Signs have cosmetics associated with them on the submap since
        // furniture can't store dynamic data to disk. To prevent writing
        // mysteriously appearing for a sign later built here, remove the
        // writing from the submap.
        delete_signage( p );
    }
 
    if( !tent ) {
        spawn_items( p, item_group::items_from( bash.drop_group, calendar::turn ) );
    }
 
    if( !bash.sound.empty() && !params.silent ) {
        static const std::string soundfxid = "smash_success";
        int sound_volume = get_sound_volume( bash );
        sounds::sound( p, sound_volume, sounds::sound_t::combat, bash.sound, false,
                       soundfxid, soundfxvariant );
    }
 
    if( bash.explosive > 0 ) {
        // TODO implement if the player triggered the explosive furniture
        explosion_handler::explosion( p, nullptr, bash.explosive, 0.8, false );
    }
 
    return result;
}

References bash(), map_data_common_t::bash, sounds::combat, fungal_effects::create_spores(), delete_signage(), map_bash_info::drop_group, explosion_handler::explosion(), f_null, furn(), furn_set(), map_bash_info::furn_set, g, get_sound_volume(), has_flag_furn(), i_at(), item_group::items_from(), map_funcs::migo_nerve_cage_removal(), int_id< T >::obj(), points_in_radius(), rad, bash_params::silent, sounds::sound(), spawn_items(), map_bash_info::tent_centers, and calendar::turn.

Referenced by bash_ter_furn().

◆ bash_items()

bash_results map::bash_items	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3662 of file map.cpp.

{
    bash_results result;
    if( !has_items( p ) ) {
        return result;
    }
 
    std::vector<item> smashed_contents;
    auto bashed_items = i_at( p );
    bool smashed_glass = false;
    for( auto bashed_item = bashed_items.begin(); bashed_item != bashed_items.end(); ) {
        // the check for active suppresses Molotovs smashing themselves with their own explosion
        if( bashed_item->made_of( material_id( "glass" ) ) && !bashed_item->active && one_in( 2 ) ) {
            result.did_bash = true;
            smashed_glass = true;
            for( const item *bashed_content : bashed_item->contents.all_items_top() ) {
                smashed_contents.push_back( item( *bashed_content ) );
            }
            bashed_item = bashed_items.erase( bashed_item );
        } else {
            ++bashed_item;
        }
    }
    // Now plunk in the contents of the smashed items.
    spawn_items( p, smashed_contents );
 
    // Add a glass sound even when something else also breaks
    if( smashed_glass && !params.silent ) {
        sounds::sound( p, 12, sounds::sound_t::combat, _( "glass shattering" ), false,
                       "smash_success", "smash_glass_contents" );
    }
    return result;
}

References _, item_contents::all_items_top(), sounds::combat, item::contents, has_items(), i_at(), one_in(), bash_params::silent, sounds::sound(), and spawn_items().

Referenced by bash().

◆ bash_rating() [1/2]

int map::bash_rating	(	const int	str,
		point	p
	)		const

inline

Definition at line 992 of file map.h.

                                                        {
            return bash_rating( str, tripoint( p, abs_sub.z ) );
        }

References abs_sub, bash_rating(), and tripoint::z.

◆ bash_rating() [2/2]

int map::bash_rating	(	int	str,
		const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns a success rating from -1 to 10 for a given tile based on a set strength, used for AI movement planning Values roughly correspond to 10% increment chances of success on a given bash, rounded down.

-1 means the square is not bashable

Definition at line 2571 of file map.cpp.

{
    if( !inbounds( p ) ) {
        dbg( DL::Warn ) << "Looking for out-of-bounds is_bashable at " << p;
        return -1;
    }
 
    if( str <= 0 ) {
        return -1;
    }
 
    const furn_t &furniture = furn( p ).obj();
    const ter_t &terrain = ter( p ).obj();
    const optional_vpart_position vp = veh_at( p );
    vehicle *const veh = vp ? &vp->vehicle() : nullptr;
    const int part = vp ? vp->part_index() : -1;
    return bash_rating_internal( str, furniture, terrain, allow_floor, veh, part );
}

References bash_rating_internal(), dbg, furn(), furniture, inbounds(), int_id< T >::obj(), ter(), terrain, veh_at(), and Warn.

Referenced by bash_rating().

◆ bash_rating_internal()

int map::bash_rating_internal	(	int	str,
		const furn_t &	furniture,
		const ter_t &	terrain,
		bool	allow_floor,
		const vehicle *	veh,
		int	part
	)		const

private

Strength determines what furniture can be smashed Strength determines what terrain can be smashed Strength increases smashing damage

Definition at line 2462 of file map.cpp.

{
    bool furn_smash = false;
    bool ter_smash = false;
    ///\EFFECT_STR determines what furniture can be smashed
    if( furniture.id && furniture.bash.str_max != -1 ) {
        furn_smash = true;
        ///\EFFECT_STR determines what terrain can be smashed
    } else if( terrain.bash.str_max != -1 && ( !terrain.bash.bash_below || allow_floor ) ) {
        ter_smash = true;
    }
 
    if( veh != nullptr && vpart_position( const_cast<vehicle &>( *veh ), part ).obstacle_at_part() ) {
        // Monsters only care about rating > 0, NPCs should want to path around cars instead
        return 2; // Should probably be a function of part hp (+armor on tile)
    }
 
    int bash_min = 0;
    int bash_max = 0;
    if( furn_smash ) {
        bash_min = furniture.bash.str_min;
        bash_max = furniture.bash.str_max;
    } else if( ter_smash ) {
        bash_min = terrain.bash.str_min;
        bash_max = terrain.bash.str_max;
    } else {
        return -1;
    }
 
    ///\EFFECT_STR increases smashing damage
    if( str < bash_min ) {
        return 0;
    } else if( str >= bash_max ) {
        return 10;
    }
 
    int ret = ( 10 * ( str - bash_min ) ) / ( bash_max - bash_min );
    // Round up to 1, so that desperate NPCs can try to bash down walls
    return std::max( ret, 1 );
}

References furniture, cata::hash64_detail::ret, and terrain.

Referenced by bash_rating(), and route().

◆ bash_resistance() [1/2]

int map::bash_resistance	(	const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns min_str of the furniture or terrain at p.

Definition at line 2557 of file map.cpp.

{
    if( has_furn( p ) && furn( p ).obj().bash.str_min != -1 ) {
        return furn( p ).obj().bash.str_min;
    }
 
    const auto &ter_bash = ter( p ).obj().bash;
    if( ter_bash.str_min != -1 && ( !ter_bash.bash_below || allow_floor ) ) {
        return ter_bash.str_min;
    }
 
    return -1;
}

References bash(), map_data_common_t::bash, furn(), has_furn(), int_id< T >::obj(), map_bash_info::str_min, and ter().

Referenced by bash_resistance(), and rate_location().

◆ bash_resistance() [2/2]

int map::bash_resistance ( point p ) const

inline

Definition at line 986 of file map.h.

                                             {
            return bash_resistance( tripoint( p, abs_sub.z ) );
        }

References abs_sub, bash_resistance(), and tripoint::z.

◆ bash_strength() [1/2]

int map::bash_strength	(	const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns max_str of the furniture or terrain at p.

Definition at line 2543 of file map.cpp.

{
    if( has_furn( p ) && furn( p ).obj().bash.str_max != -1 ) {
        return furn( p ).obj().bash.str_max;
    }
 
    const auto &ter_bash = ter( p ).obj().bash;
    if( ter_bash.str_max != -1 && ( !ter_bash.bash_below || allow_floor ) ) {
        return ter_bash.str_max;
    }
 
    return -1;
}

References bash(), map_data_common_t::bash, furn(), has_furn(), int_id< T >::obj(), map_bash_info::str_max, and ter().

Referenced by bash_strength(), and game::fling_creature().

◆ bash_strength() [2/2]

int map::bash_strength ( point p ) const

inline

Definition at line 981 of file map.h.

                                           {
            return bash_strength( tripoint( p, abs_sub.z ) );
        }

References abs_sub, bash_strength(), and tripoint::z.

◆ bash_ter_furn()

bash_results map::bash_ter_furn	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3500 of file map.cpp.

{
    bash_results result;
    std::string soundfxvariant;
    const auto &ter_obj = ter( p ).obj();
    const auto &furn_obj = furn( p ).obj();
    bool smash_ter = false;
    const map_bash_info *bash = nullptr;
 
    if( furn_obj.id && furn_obj.bash.str_max != -1 ) {
        bash = &furn_obj.bash;
        soundfxvariant = furn_obj.id.str();
    } else if( ter_obj.bash.str_max != -1 ) {
        bash = &ter_obj.bash;
        smash_ter = true;
        soundfxvariant = ter_obj.id.str();
    }
 
    // Floor bashing check
    // Only allow bashing floors when we want to bash floors and we're in z-level mode
    // Unless we're destroying, then it gets a little weird
    if( smash_ter && bash->bash_below && ( !zlevels || !params.bash_floor ) ) {
        if( !params.destroy ) {
            smash_ter = false;
            bash = nullptr;
        } else if( !bash->ter_set && zlevels ) {
            // HACK: A hack for destroy && !bash_floor
            // We have to check what would we create and cancel if it is what we have now
            tripoint below( p.xy(), p.z - 1 );
            const auto roof = get_roof( below, false );
            if( roof == ter( p ) ) {
                smash_ter = false;
                bash = nullptr;
            }
        } else if( !bash->ter_set && ter( p ) == t_dirt ) {
            // As above, except for no-z-levels case
            smash_ter = false;
            bash = nullptr;
        }
    }
 
    // TODO: what if silent is true?
    if( has_flag( "ALARMED", p ) && !g->timed_events.queued( TIMED_EVENT_WANTED ) ) {
        sounds::sound( p, 40, sounds::sound_t::alarm, _( "an alarm go off!" ),
                       false, "environment", "alarm" );
        // Blame nearby player
        if( rl_dist( g->u.pos(), p ) <= 3 ) {
            g->events().send<event_type::triggers_alarm>( g->u.getID() );
            const point abs = ms_to_sm_copy( getabs( p.xy() ) );
            g->timed_events.add( TIMED_EVENT_WANTED, calendar::turn + 30_minutes, 0,
                                 tripoint( abs, p.z ) );
        }
    }
 
    if( bash == nullptr || ( bash->destroy_only && !params.destroy ) ) {
        // Nothing bashable here
        if( impassable( p ) ) {
            if( !params.silent ) {
                sounds::sound( p, 18, sounds::sound_t::combat, _( "thump!" ),
                               false, "smash_fail", "default" );
            }
 
            result.did_bash = true;
            result.bashed_solid = true;
        }
 
        return result;
    }
 
    result.did_bash = true;
    result.bashed_solid = true;
    result.success = params.destroy;
 
    int smin = bash->str_min;
    int smax = bash->str_max;
    if( !params.destroy ) {
        if( bash->str_min_blocked != -1 || bash->str_max_blocked != -1 ) {
            if( furn_is_supported( *this, p ) ) {
                if( bash->str_min_blocked != -1 ) {
                    smin = bash->str_min_blocked;
                }
                if( bash->str_max_blocked != -1 ) {
                    smax = bash->str_max_blocked;
                }
            }
        }
 
        if( bash->str_min_supported != -1 || bash->str_max_supported != -1 ) {
            tripoint below( p.xy(), p.z - 1 );
            if( !zlevels || has_flag( TFLAG_SUPPORTS_ROOF, below ) ) {
                if( bash->str_min_supported != -1 ) {
                    smin = bash->str_min_supported;
                }
                if( bash->str_max_supported != -1 ) {
                    smax = bash->str_max_supported;
                }
            }
        }
        // Linear interpolation from str_min to str_max
        const int resistance = smin + ( params.roll * ( smax - smin ) );
        if( params.strength >= resistance ) {
            result.success = true;
        }
    }
 
    if( !result.success ) {
        int sound_volume = bash->sound_fail_vol.value_or( 12 );
 
        result.did_bash = true;
        if( !params.silent ) {
            sounds::sound( p, sound_volume, sounds::sound_t::combat, bash->sound_fail, false,
                           "smash_fail", soundfxvariant );
        }
    } else {
        if( smash_ter ) {
            result |= bash_ter_success( p, params );
        } else {
            result |= bash_furn_success( p, params );
        }
    }
 
    return result;
}

References _, sounds::alarm, bash(), bash_params::bash_floor, bash_furn_success(), bash_ter_success(), sounds::combat, bash_params::destroy, furn(), furn_is_supported(), g, get_roof(), getabs(), has_flag(), impassable(), ms_to_sm_copy(), int_id< T >::obj(), rl_dist(), bash_params::roll, bash_params::silent, sounds::sound(), bash_params::strength, t_dirt, ter(), TFLAG_SUPPORTS_ROOF, TIMED_EVENT_WANTED, triggers_alarm, calendar::turn, tripoint::xy(), tripoint::z, and zlevels.

Referenced by bash(), and bash_ter_success().

◆ bash_ter_success()

bash_results map::bash_ter_success	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3270 of file map.cpp.

{
    bash_results result;
    result.success = true;
    const ter_t &ter_before = ter( p ).obj();
    const map_bash_info &bash = ter_before.bash;
    if( has_flag_ter( "FUNGUS", p ) ) {
        fungal_effects( *g, *this ).create_spores( p );
    }
    const std::string soundfxvariant = ter_before.id.str();
    const bool will_collapse = ter_before.has_flag( TFLAG_SUPPORTS_ROOF ) &&
                               !ter_before.has_flag( TFLAG_INDOORS );
    const bool suspended = ter_before.has_flag( TFLAG_SUSPENDED );
    bool follow_below = false;
    if( params.bashing_from_above && bash.ter_set_bashed_from_above ) {
        // If this terrain is being bashed from above and this terrain
        // has a valid post-destroy bashed-from-above terrain, set it
        ter_set( p, bash.ter_set_bashed_from_above );
    } else if( bash.ter_set ) {
        // If the terrain has a valid post-destroy terrain, set it
        ter_set( p, bash.ter_set );
        follow_below |= zlevels && bash.bash_below;
    } else if( suspended ) {
        // Its important that we change the ter value before recursing, otherwise we'll hit an infinite loop.
        // This could be prevented by assembling a visited list, but in order to avoid that cost, we're going
        // build our recursion to just be resilient.
        ter_set( p, t_open_air );
        propagate_suspension_check( p );
    } else {
        tripoint below( p.xy(), p.z - 1 );
        const ter_t &ter_below = ter( below ).obj();
        // Only setting the flag here because we want drops and sounds in correct order
        follow_below |= zlevels && bash.bash_below && ter_below.roof;
 
        ter_set( p, t_open_air );
    }
 
    spawn_items( p, item_group::items_from( bash.drop_group, calendar::turn ) );
 
    if( !bash.sound.empty() && !params.silent ) {
        static const std::string soundfxid = "smash_success";
        int sound_volume = get_sound_volume( bash );
        sounds::sound( p, sound_volume, sounds::sound_t::combat, bash.sound, false,
                       soundfxid, soundfxvariant );
    }
 
    if( !zlevels ) {
        if( ter( p ) == t_open_air ) {
            // We destroyed something, so we aren't just "plugging" air with dirt here
            ter_set( p, t_dirt );
        }
    } else if( follow_below || ter( p ) == t_open_air ) {
        const tripoint below( p.xy(), p.z - 1 );
        // We may need multiple bashes in some weird cases
        // Example:
        //   W has roof A
        //   A bashes to B
        //   B bashes to nothing
        //   Below our point P, there is a W
        // If we bash down a B over a W, it might be from earlier A or just constructed over it!
        //
        // Current solution: bash roof until you reach same roof type twice, then bash down
        if( follow_below && params.do_recurse ) {
            bool blocked_by_roof = false;
            std::set<ter_id> encountered_types;
            encountered_types.insert( ter_before.id );
            encountered_types.insert( t_open_air );
            // Note: we're bashing the new roof, not the tile supported by it!
            int down_bash_tries = 10;
            do {
                const ter_id &ter_now = ter( p );
                if( encountered_types.count( ter_now ) != 0 ) {
                    // We have encountered this type before and destroyed it (didn't block us)
                    ter_set( p, t_open_air );
                    bash_params params_below = params;
                    params_below.bashing_from_above = true;
                    params_below.bash_floor = false;
                    params_below.do_recurse = false;
                    params_below.destroy = true;
                    int impassable_bash_tries = 10;
                    // Unconditionally destroy, but don't go deeper
                    do {
                        result |= bash_ter_success( below, params_below );
                    } while( ter( below )->movecost == 0 && impassable_bash_tries-- > 0 );
                    if( impassable_bash_tries <= 0 ) {
                        debugmsg( "Loop in terrain bashing for type %s", ter_before.id.str() );
                    }
                } else if( ter_now == t_open_air ) {
                    const ter_id &roof = get_roof( below, params.bash_floor && ter( below )->movecost != 0 );
                    if( roof != t_open_air ) {
                        ter_set( p, roof );
                    }
                } else {
                    // This floor/roof tile wasn't destroyed in this loop yet
                    encountered_types.insert( ter_now );
                    bash_params params_copy = params;
                    params_copy.do_recurse = false;
                    // TODO: Unwrap the calls, don't recurse
                    // TODO: Don't bash furn
                    bash_results results_sub = bash_ter_furn( p, params_copy );
                    result |= results_sub;
                    if( !results_sub.success ) {
                        // Blocked, as in "the roof was too strong to bash"
                        blocked_by_roof = true;
                    }
                }
            } while( down_bash_tries-- > 0 && !blocked_by_roof &&
                     ( ter( p ) != t_open_air || ter( p )->movecost == 0 || ter( below )->roof ) );
            if( down_bash_tries <= 0 ) {
                debugmsg( "Loop in terrain bashing for type %s", ter_before.id.str() );
            }
        } else {
            const ter_id &roof = get_roof( below, params.bash_floor && ter( below )->movecost != 0 );
 
            ter_set( p, roof );
        }
    }
 
    if( will_collapse && !has_flag( TFLAG_SUPPORTS_ROOF, p ) ) {
        collapse_at( p, params.silent, true, bash.explosive > 0 );
    }
 
    if( bash.explosive > 0 ) {
        // TODO Implement if the player triggered the explosive terrain
        explosion_handler::explosion( p, nullptr, bash.explosive, 0.8, false );
    }
 
    return result;
}

References bash(), map_data_common_t::bash, bash_params::bash_floor, bash_ter_furn(), bash_ter_success(), bash_params::bashing_from_above, collapse_at(), sounds::combat, fungal_effects::create_spores(), debugmsg, bash_params::destroy, bash_params::do_recurse, explosion_handler::explosion(), g, get_roof(), get_sound_volume(), map_data_common_t::has_flag(), has_flag(), has_flag_ter(), ter_t::id, item_group::items_from(), int_id< T >::obj(), propagate_suspension_check(), ter_t::roof, bash_params::silent, sounds::sound(), spawn_items(), string_id< T >::str(), bash_results::success, t_dirt, t_open_air, ter(), ter_set(), TFLAG_INDOORS, TFLAG_SUPPORTS_ROOF, TFLAG_SUSPENDED, calendar::turn, tripoint::xy(), tripoint::z, and zlevels.

Referenced by bash_ter_furn(), bash_ter_success(), and shoot().

◆ bash_vehicle()

bash_results map::bash_vehicle	(	const tripoint &	p,
		const bash_params &	params
	)

Definition at line 3696 of file map.cpp.

{
    bash_results result;
    // Smash vehicle if present
    if( const optional_vpart_position vp = veh_at( p ) ) {
        vp->vehicle().damage( vp->part_index(), params.strength, DT_BASH );
        if( !params.silent ) {
            sounds::sound( p, 18, sounds::sound_t::combat, _( "crash!" ), false,
                           "smash_success", "hit_vehicle" );
        }
 
        result.did_bash = true;
        result.success = true;
        result.bashed_solid = true;
    }
    return result;
}

References _, sounds::combat, DT_BASH, bash_params::silent, sounds::sound(), bash_params::strength, and veh_at().

Referenced by bash().

◆ batter()

void map::batter	(	const tripoint &	p,
		int	power,
		int	tries = `1`,
		bool	silent = `false`
	)

bash a square for a set number of times at set power.

Does not destroy

Definition at line 3761 of file map.cpp.

{
    int count = 0;
    while( count < tries && bash( p, power, silent ).success ) {
        count++;
    }
}

References bash(), detail::count(), silent, and behavior::success.

◆ board_vehicle()

void map::board_vehicle	(	const tripoint &	p,
		player *	pl
	)

Definition at line 1114 of file map.cpp.

{
    if( p == nullptr ) {
        debugmsg( "map::board_vehicle: null player" );
        return;
    }
 
    const std::optional<vpart_reference> vp = veh_at( pos ).part_with_feature( VPFLAG_BOARDABLE,
            true );
    if( !vp ) {
        if( p->grab_point.x == 0 && p->grab_point.y == 0 ) {
            debugmsg( "map::board_vehicle: vehicle not found" );
        }
        return;
    }
    if( vp->part().has_flag( vehicle_part::passenger_flag ) ) {
        player *psg = vp->vehicle().get_passenger( vp->part_index() );
        debugmsg( "map::board_vehicle: passenger (%s) is already there",
                  psg ? psg->name : "<null>" );
        unboard_vehicle( pos );
    }
    vp->part().set_flag( vehicle_part::passenger_flag );
    vp->part().passenger_id = p->getID();
    vp->vehicle().invalidate_mass();
 
    p->setpos( pos );
    p->in_vehicle = true;
    if( p->is_avatar() ) {
        g->update_map( g->u );
    }
}

References debugmsg, g, Character::getID(), player::grab_point, Character::in_vehicle, Creature::is_avatar(), Character::name, optional_vpart_position::part_with_feature(), vehicle_part::passenger_flag, wrapped_vehicle::pos, Character::setpos(), unboard_vehicle(), veh_at(), VPFLAG_BOARDABLE, tripoint::x, and tripoint::y.

Referenced by debug_menu::debug(), game::phasing_move(), game::place_player(), game::swap_critters(), and avatar_action::swim().

◆ build_floor_cache()

bool map::build_floor_cache ( int zlev )

Definition at line 8148 of file map.cpp.

{
    auto &ch = get_cache( zlev );
    if( !ch.floor_cache_dirty ) {
        return false;
    }
 
    auto &floor_cache = ch.floor_cache;
    std::uninitialized_fill_n(
        &floor_cache[0][0], ( MAPSIZE_X ) * ( MAPSIZE_Y ), true );
 
    bool lowest_z_lev = zlev <= -OVERMAP_DEPTH;
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const submap *cur_submap = get_submap_at_grid( { smx, smy, zlev } );
            const submap *below_submap = !lowest_z_lev ? get_submap_at_grid( { smx, smy, zlev - 1 } ) : nullptr;
 
            if( cur_submap == nullptr ) {
                debugmsg( "Tried to build floor cache at (%d,%d,%d) but the submap is not loaded", smx, smy, zlev );
                continue;
            }
            if( !lowest_z_lev && below_submap == nullptr ) {
                debugmsg( "Tried to build floor cache at (%d,%d,%d) but the submap is not loaded", smx, smy,
                          zlev - 1 );
                continue;
            }
 
            for( int sx = 0; sx < SEEX; ++sx ) {
                for( int sy = 0; sy < SEEY; ++sy ) {
                    point sp( sx, sy );
                    const ter_t &terrain = cur_submap->get_ter( sp ).obj();
                    if( terrain.has_flag( TFLAG_NO_FLOOR ) ) {
                        if( below_submap && ( below_submap->get_furn( sp ).obj().has_flag( TFLAG_SUN_ROOF_ABOVE ) ) ) {
                            continue;
                        }
                        const int x = sx + smx * SEEX;
                        const int y = sy + smy * SEEY;
                        floor_cache[x][y] = false;
                    }
                }
            }
        }
    }
 
    ch.floor_cache_dirty = false;
    return zlevels;
}

References debugmsg, get_cache(), get_submap_at_grid(), submap::get_ter(), MAPSIZE_X, MAPSIZE_Y, my_MAPSIZE, int_id< T >::obj(), OVERMAP_DEPTH, SEEX, SEEY, sx, sy, terrain, TFLAG_NO_FLOOR, TFLAG_SUN_ROOF_ABOVE, and zlevels.

Referenced by build_floor_caches(), and build_map_cache().

◆ build_floor_caches()

void map::build_floor_caches ( )

Definition at line 8196 of file map.cpp.

{
    const int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int z = minz; z <= maxz; z++ ) {
        build_floor_cache( z );
    }
}

References abs_sub, build_floor_cache(), OVERMAP_DEPTH, OVERMAP_HEIGHT, tripoint::z, and zlevels.

Referenced by game::do_turn().

◆ build_map_cache()

void map::build_map_cache	(	int	zlev,
		bool	skip_lightmap = `false`
	)

Definition at line 8362 of file map.cpp.

{
    const int minz = zlevels ? -OVERMAP_DEPTH : zlev;
    const int maxz = zlevels ? OVERMAP_HEIGHT : zlev;
    bool seen_cache_dirty = false;
    for( int z = minz; z <= maxz; z++ ) {
        // trigger FOV recalculation only when there is a change on the player's level or if fov_3d is enabled
        const bool affects_seen_cache =  z == zlev || fov_3d;
        build_outside_cache( z );
        build_transparency_cache( z );
        update_suspension_cache( z );
        seen_cache_dirty |= ( build_floor_cache( z ) && affects_seen_cache );
        seen_cache_dirty |= get_cache( z ).seen_cache_dirty && affects_seen_cache;
        diagonal_blocks fill = {false, false};
        std::uninitialized_fill_n( &( get_cache( z ).vehicle_obscured_cache[0][0] ), MAPSIZE_X * MAPSIZE_Y,
                                   fill );
        std::uninitialized_fill_n( &( get_cache( z ).vehicle_obstructed_cache[0][0] ),
                                   MAPSIZE_X * MAPSIZE_Y, fill );
    }
    // needs a separate pass as it changes the caches on neighbour z-levels (e.g. floor_cache);
    // otherwise such changes might be overwritten by main cache-building logic
    for( int z = minz; z <= maxz; z++ ) {
        do_vehicle_caching( z );
    }
 
    seen_cache_dirty |= build_vision_transparency_cache( get_player_character() );
 
    if( seen_cache_dirty ) {
        skew_vision_cache.clear();
    }
    // Initial value is illegal player position.
    const tripoint &p = g->u.pos();
    static tripoint player_prev_pos;
    if( seen_cache_dirty || player_prev_pos != p ) {
        build_seen_cache( p, zlev );
        player_prev_pos = p;
    }
    if( !skip_lightmap ) {
        generate_lightmap( zlev );
    }
}

References build_floor_cache(), build_outside_cache(), build_seen_cache(), build_transparency_cache(), build_vision_transparency_cache(), do_vehicle_caching(), detail::fill(), fov_3d, g, generate_lightmap(), get_cache(), get_player_character(), MAPSIZE_X, MAPSIZE_Y, OVERMAP_DEPTH, OVERMAP_HEIGHT, level_cache::seen_cache_dirty, skew_vision_cache, update_suspension_cache(), and zlevels.

Referenced by game::do_turn(), game::draw(), game::look_around(), start_location::place_player(), game::start_game(), and game::update_map().

◆ build_obstacle_cache()

void map::build_obstacle_cache	(	const tripoint &	start,
		const tripoint &	end,
		float(&)	obstacle_cache[MAPSIZE_X][MAPSIZE_Y]
	)

Definition at line 8095 of file map.cpp.

{
    const point min_submap{ std::max( 0, start.x / SEEX ), std::max( 0, start.y / SEEY ) };
    const point max_submap{
        std::min( my_MAPSIZE - 1, end.x / SEEX ), std::min( my_MAPSIZE - 1, end.y / SEEY ) };
    // Find and cache all the map obstacles.
    // For now setting obstacles to be extremely dense and fill their squares.
    // In future, scale effective obstacle density by the thickness of the obstacle.
    // Also consider modelling partial obstacles.
    // TODO: Support z-levels.
    for( int smx = min_submap.x; smx <= max_submap.x; ++smx ) {
        for( int smy = min_submap.y; smy <= max_submap.y; ++smy ) {
            const auto cur_submap = get_submap_at_grid( { smx, smy, start.z } );
 
            // TODO: Init indices to prevent iterating over unused submap sections.
            for( int sx = 0; sx < SEEX; ++sx ) {
                for( int sy = 0; sy < SEEY; ++sy ) {
                    const point sp( sx, sy );
                    int ter_move = cur_submap->get_ter( sp ).obj().movecost;
                    int furn_move = cur_submap->get_furn( sp ).obj().movecost;
                    const int x = sx + smx * SEEX;
                    const int y = sy + smy * SEEY;
                    if( ter_move == 0 || furn_move < 0 || ter_move + furn_move == 0 ) {
                        obstacle_cache[x][y] = 1000.0f;
                    } else {
                        obstacle_cache[x][y] = 0.0f;
                    }
                }
            }
        }
    }
    VehicleList vehs = get_vehicles( start, end );
    const inclusive_cuboid<tripoint> bounds( start, end );
    // Cache all the vehicle stuff in one loop
    for( auto &v : vehs ) {
        for( const vpart_reference &vp : v.v->get_all_parts() ) {
            tripoint p = v.pos + vp.part().precalc[0];
            if( p.z != start.z ) {
                break;
            }
            if( !bounds.contains( p ) ) {
                continue;
            }
 
            if( vp.obstacle_at_part() ) {
                obstacle_cache[p.x][p.y] = 1000.0f;
            }
        }
    }
 
}

References inclusive_cuboid< Tripoint, >::contains(), get_submap_at_grid(), get_vehicles(), my_MAPSIZE, SEEX, SEEY, sx, sy, tripoint::x, tripoint::y, and tripoint::z.

◆ build_outside_cache()

void map::build_outside_cache ( int zlev )

Definition at line 8041 of file map.cpp.

{
    auto &ch = get_cache( zlev );
    if( !ch.outside_cache_dirty ) {
        return;
    }
 
    // Make a bigger cache to avoid bounds checking
    // We will later copy it to our regular cache
    const size_t padded_w = ( MAPSIZE_X ) + 2;
    const size_t padded_h = ( MAPSIZE_Y ) + 2;
    bool padded_cache[padded_w][padded_h];
 
    auto &outside_cache = ch.outside_cache;
    if( zlev < 0 ) {
        std::uninitialized_fill_n(
            &outside_cache[0][0], ( MAPSIZE_X ) * ( MAPSIZE_Y ), false );
        return;
    }
 
    std::uninitialized_fill_n(
        &padded_cache[0][0], padded_w * padded_h, true );
 
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const auto cur_submap = get_submap_at_grid( { smx, smy, zlev } );
 
            for( int sx = 0; sx < SEEX; ++sx ) {
                for( int sy = 0; sy < SEEY; ++sy ) {
                    point sp( sx, sy );
                    if( cur_submap->get_ter( sp ).obj().has_flag( TFLAG_INDOORS ) ||
                        cur_submap->get_furn( sp ).obj().has_flag( TFLAG_INDOORS ) ) {
                        const int x = sx + smx * SEEX;
                        const int y = sy + smy * SEEY;
                        // Add 1 to both coordinates, because we're operating on the padded cache
                        for( int dx = 0; dx <= 2; dx++ ) {
                            for( int dy = 0; dy <= 2; dy++ ) {
                                padded_cache[x + dx][y + dy] = false;
                            }
                        }
                    }
                }
            }
        }
    }
 
    // Copy the padded cache back to the proper one, but with no padding
    for( int x = 0; x < SEEX * my_MAPSIZE; x++ ) {
        std::copy_n( &padded_cache[x + 1][1], SEEX * my_MAPSIZE, &outside_cache[x][0] );
    }
 
    ch.outside_cache_dirty = false;
}

References get_cache(), get_submap_at_grid(), MAPSIZE_X, MAPSIZE_Y, my_MAPSIZE, SEEX, SEEY, sx, sy, and TFLAG_INDOORS.

Referenced by build_map_cache(), start_location::burn(), and start_location::prepare_map().

◆ build_seen_cache()

void map::build_seen_cache	(	const tripoint &	origin,
		int	target_z
	)

protected

Calculates the Field Of View for the provided map from the given x, y coordinates.

Returns a lightmap for a result where the values represent a percentage of fully lit.

A value equal to or below 0 means that cell is not in the field of view, whereas a value equal to or above 1 means that cell is in the field of view.

Parameters

origin	the starting location
target_z	Z-level to draw light map on

Definition at line 1592 of file lightmap.cpp.

{
    auto &map_cache = get_cache( target_z );
    float ( &transparency_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.transparency_cache;
    float ( &seen_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.seen_cache;
    float ( &camera_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.camera_cache;
    diagonal_blocks( &blocked_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.vehicle_obscured_cache;
 
    constexpr float light_transparency_solid = LIGHT_TRANSPARENCY_SOLID;
    constexpr int map_dimensions = MAPSIZE_X * MAPSIZE_Y;
    std::uninitialized_fill_n(
        &camera_cache[0][0], map_dimensions, light_transparency_solid );
 
    float vision_restore_cache [9] = {0};
    bool blocked_restore_cache[8] = {false};
 
    if( origin.z == target_z ) {
        apply_vision_transparency_cache( get_player_character().pos(), target_z, vision_restore_cache,
                                         blocked_restore_cache );
    }
 
    if( !fov_3d ) {
        for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
            auto &cur_cache = get_cache( z );
            if( z == target_z || cur_cache.seen_cache_dirty ) {
                std::uninitialized_fill_n(
                    &cur_cache.seen_cache[0][0], map_dimensions, light_transparency_solid );
                cur_cache.seen_cache_dirty = false;
            }
 
            if( z == target_z ) {
                seen_cache[origin.x][origin.y] = VISIBILITY_FULL;
                castLightAllWithLookup<float, float, sight_calc, sight_check, update_light, accumulate_transparency, sight_from_lookup>
                ( seen_cache, transparency_cache, blocked_cache, origin.xy(), 0 );
            }
        }
    } else {
        // Cache the caches (pointers to them)
        array_of_grids_of<const float> transparency_caches;
        array_of_grids_of<float> seen_caches;
        array_of_grids_of<const bool> floor_caches;
        array_of_grids_of < const diagonal_blocks > blocked_caches;
        for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
            auto &cur_cache = get_cache( z );
            transparency_caches[z + OVERMAP_DEPTH] = &cur_cache.transparency_cache;
            seen_caches[z + OVERMAP_DEPTH] = &cur_cache.seen_cache;
            floor_caches[z + OVERMAP_DEPTH] = &cur_cache.floor_cache;
            blocked_caches[z + OVERMAP_DEPTH] = &cur_cache.vehicle_obscured_cache;
            std::uninitialized_fill_n(
                &cur_cache.seen_cache[0][0], map_dimensions, light_transparency_solid );
            cur_cache.seen_cache_dirty = false;
        }
        if( origin.z == target_z ) {
            get_cache( origin.z ).seen_cache[origin.x][origin.y] = VISIBILITY_FULL;
        }
        cast_zlight<float, sight_calc, sight_check, accumulate_transparency>(
            seen_caches, transparency_caches, floor_caches, blocked_caches, origin, 0, 1.0 );
    }
 
    if( origin.z == target_z ) {
        restore_vision_transparency_cache( get_player_character().pos(), target_z, vision_restore_cache,
                                           blocked_restore_cache );
    }
 
    const optional_vpart_position vp = veh_at( origin );
    if( !vp ) {
        return;
    }
    vehicle *const veh = &vp->vehicle();
 
    // We're inside a vehicle. Do mirror calculations.
    std::vector<int> mirrors;
    // Do all the sight checks first to prevent fake multiple reflection
    // from happening due to mirrors becoming visible due to processing order.
    // Cameras are also handled here, so that we only need to get through all vehicle parts once
    int cam_control = -1;
    for( const vpart_reference &vp : veh->get_avail_parts( VPFLAG_EXTENDS_VISION ) ) {
        const tripoint mirror_pos = vp.pos();
        // We can utilize the current state of the seen cache to determine
        // if the player can see the mirror from their position.
        if( !vp.info().has_flag( "CAMERA" ) &&
            seen_cache[mirror_pos.x][mirror_pos.y] < LIGHT_TRANSPARENCY_SOLID + 0.1 ) {
            continue;
        } else if( !vp.info().has_flag( "CAMERA_CONTROL" ) ) {
            mirrors.emplace_back( static_cast<int>( vp.part_index() ) );
        } else {
            if( square_dist( origin, mirror_pos ) <= 1 && veh->camera_on ) {
                cam_control = static_cast<int>( vp.part_index() );
            }
        }
    }
 
    for( int mirror : mirrors ) {
        bool is_camera = veh->part_info( mirror ).has_flag( "CAMERA" );
        if( is_camera && cam_control < 0 ) {
            continue; // Player not at camera control, so cameras don't work
        }
 
        const tripoint mirror_pos = veh->global_part_pos3( mirror );
 
        // Determine how far the light has already traveled so mirrors
        // don't cheat the light distance falloff.
        int offsetDistance;
        if( !is_camera ) {
            offsetDistance = rl_dist( origin, mirror_pos );
        } else {
            offsetDistance = 60 - veh->part_info( mirror ).bonus *
                             veh->part( mirror ).hp() / veh->part_info( mirror ).durability;
            camera_cache[mirror_pos.x][mirror_pos.y] = LIGHT_TRANSPARENCY_OPEN_AIR;
        }
 
        // TODO: Factor in the mirror facing and only cast in the
        // directions the player's line of sight reflects to.
        //
        // The naive solution of making the mirrors act like a second player
        // at an offset appears to give reasonable results though.
        castLightAllWithLookup<float, float, sight_calc, sight_check, update_light, accumulate_transparency, sight_from_lookup>
        (
            camera_cache, transparency_cache, blocked_cache, mirror_pos.xy(), offsetDistance );
    }
}

References apply_vision_transparency_cache(), vpart_info::bonus, vehicle::camera_on, cast_zlight< float, sight_calc, sight_check, accumulate_transparency >(), castLightAllWithLookup< float, float, sight_calc, sight_check, update_light, accumulate_transparency, sight_from_lookup >(), vpart_info::durability, fov_3d, vehicle::get_avail_parts(), get_cache(), get_player_character(), vehicle::global_part_pos3(), vpart_info::has_flag(), vehicle_part::hp(), LIGHT_TRANSPARENCY_OPEN_AIR, LIGHT_TRANSPARENCY_SOLID, MAPSIZE_X, MAPSIZE_Y, OVERMAP_DEPTH, OVERMAP_HEIGHT, vehicle::part(), vehicle::part_info(), restore_vision_transparency_cache(), rl_dist(), level_cache::seen_cache, square_dist(), veh_at(), VISIBILITY_FULL, VPFLAG_EXTENDS_VISION, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by build_map_cache().

◆ build_sunlight_cache()

void map::build_sunlight_cache ( int pzlev )

protected

Definition at line 285 of file lightmap.cpp.

{
    const int zlev_min = zlevels ? -OVERMAP_DEPTH : pzlev;
    // Start at the topmost populated zlevel to avoid unnecessary raycasting
    // Plus one zlevel to prevent clipping inside structures
    const int zlev_max = zlevels
                         ? clamp( calc_max_populated_zlev() + 1,
                                  std::min( OVERMAP_HEIGHT, pzlev + 1 ),
                                  OVERMAP_HEIGHT )
                         : pzlev;
 
    // true if all previous z-levels are fully transparent to light (no floors, transparency >= air)
    bool fully_outside = true;
 
    // true if no light reaches this level, i.e. there were no lit tiles on the above level (light level <= inside_light_level)
    bool fully_inside = false;
 
    // fully_outside and fully_inside define following states:
    // initially: fully_outside=true, fully_inside=false  (fast fill)
    //    ↓
    // when first obstacles occur: fully_outside=false, fully_inside=false  (slow quadrant logic)
    //    ↓
    // when fully below ground: fully_outside=false, fully_inside=true  (fast fill)
 
    // Iterate top to bottom because sunlight cache needs to construct in that order.
    for( int zlev = zlev_max; zlev >= zlev_min; zlev-- ) {
 
        level_cache &map_cache = get_cache( zlev );
        auto &lm = map_cache.lm;
        // Grab illumination at ground level.
        const float outside_light_level = g->natural_light_level( 0 );
        // TODO: if zlev < 0 is open to sunlight, this won't calculate correct light, but neither does g->natural_light_level()
        const float inside_light_level = ( zlev >= 0 && outside_light_level > LIGHT_SOURCE_BRIGHT ) ?
                                         LIGHT_AMBIENT_DIM * 0.8 : LIGHT_AMBIENT_LOW;
        // Handling when z-levels are disabled is based on whether a tile is considered "outside".
        if( !zlevels ) {
            const auto &outside_cache = map_cache.outside_cache;
            for( int x = 0; x < MAPSIZE_X; x++ ) {
                for( int y = 0; y < MAPSIZE_Y; y++ ) {
                    if( outside_cache[x][y] ) {
                        lm[x][y].fill( outside_light_level );
                    } else {
                        lm[x][y].fill( inside_light_level );
                    }
                }
            }
            continue;
        }
 
        // all light was blocked before
        if( fully_inside ) {
            std::fill_n( &lm[0][0], MAPSIZE_X * MAPSIZE_Y, four_quadrants( inside_light_level ) );
            continue;
        }
 
        // If there were no obstacles before this level, just apply weather illumination since there's no opportunity
        // for light to be blocked.
        if( fully_outside ) {
            //fill with full light
            std::fill_n( &lm[0][0], MAPSIZE_X * MAPSIZE_Y, four_quadrants( outside_light_level ) );
 
            const auto &this_floor_cache = map_cache.floor_cache;
            const auto &this_transparency_cache = map_cache.transparency_cache;
            fully_inside = true; // recalculate
 
            for( int x = 0; x < MAPSIZE_X; ++x ) {
                for( int y = 0; y < MAPSIZE_Y; ++y ) {
                    // && semantics below is important, we want to skip the evaluation if possible, do not replace with &=
 
                    // fully_outside stays true if tile is transparent and there is no floor
                    fully_outside = fully_outside && this_transparency_cache[x][y] >= LIGHT_TRANSPARENCY_OPEN_AIR
                                    && !this_floor_cache[x][y];
                    // fully_inside stays true if tile is opaque OR there is floor
                    fully_inside = fully_inside && ( this_transparency_cache[x][y] <= LIGHT_TRANSPARENCY_SOLID ||
                                                     this_floor_cache[x][y] );
                }
            }
            continue;
        }
 
        // Replace this with a calculated shift based on time of day and date.
        // At first compress the angle such that it takes no more than one tile of shift per level.
        // To exceed that, we'll have to handle casting light from the side instead of the top.
        point offset;
        const level_cache &prev_map_cache = get_cache_ref( zlev + 1 );
        const auto &prev_lm = prev_map_cache.lm;
        const auto &prev_transparency_cache = prev_map_cache.transparency_cache;
        const auto &prev_floor_cache = prev_map_cache.floor_cache;
        const auto &outside_cache = map_cache.outside_cache;
        const float sight_penalty = get_weather().weather_id->sight_penalty;
        // TODO: Replace these with a lookup inside the four_quadrants class.
        constexpr std::array<point, 5> cardinals = {
            {point_zero, point_north, point_west, point_east, point_south}
        };
        constexpr std::array<std::array<quadrant, 2>, 5> dir_quadrants = {{
                {{quadrant::NE, quadrant::NW}},
                {{quadrant::NE, quadrant::NW}},
                {{quadrant::SW, quadrant::NW}},
                {{quadrant::SE, quadrant::NE}},
                {{quadrant::SE, quadrant::SW}},
            }
        };
 
        fully_inside = true; // recalculate
 
        // Fall back to minimal light level if we don't find anything.
        std::fill_n( &lm[0][0], MAPSIZE_X * MAPSIZE_Y, four_quadrants( inside_light_level ) );
 
        for( int x = 0; x < MAPSIZE_X; ++x ) {
            for( int y = 0; y < MAPSIZE_Y; ++y ) {
                // Check center, then four adjacent cardinals.
                for( int i = 0; i < 5; ++i ) {
                    int prev_x = x + offset.x + cardinals[i].x;
                    int prev_y = y + offset.y + cardinals[i].y;
                    bool inbounds = prev_x >= 0 && prev_x < MAPSIZE_X &&
                                    prev_y >= 0 && prev_y < MAPSIZE_Y;
 
                    if( !inbounds ) {
                        continue;
                    }
 
                    float prev_light_max;
                    float prev_transparency = prev_transparency_cache[prev_x][prev_y];
                    // This is pretty gross, this cancels out the per-tile transparency effect
                    // derived from weather.
                    if( outside_cache[x][y] ) {
                        prev_transparency /= sight_penalty;
                    }
 
                    if( prev_transparency > LIGHT_TRANSPARENCY_SOLID &&
                        !prev_floor_cache[prev_x][prev_y] &&
                        ( prev_light_max = prev_lm[prev_x][prev_y].max() ) > 0.0 ) {
                        const float light_level = clamp( prev_light_max * LIGHT_TRANSPARENCY_OPEN_AIR / prev_transparency,
                                                         inside_light_level, prev_light_max );
 
                        if( i == 0 ) {
                            lm[x][y].fill( light_level );
                            fully_inside &= light_level <= inside_light_level;
                            break;
                        } else {
                            fully_inside &= light_level <= inside_light_level;
                            lm[x][y][dir_quadrants[i][0]] = light_level;
                            lm[x][y][dir_quadrants[i][1]] = light_level;
                        }
                    }
                }
            }
        }
    }
}

References calc_max_populated_zlev(), clamp(), level_cache::floor_cache, g, get_cache(), get_cache_ref(), get_weather(), inbounds(), LIGHT_AMBIENT_DIM, LIGHT_AMBIENT_LOW, LIGHT_SOURCE_BRIGHT, LIGHT_TRANSPARENCY_OPEN_AIR, LIGHT_TRANSPARENCY_SOLID, level_cache::lm, MAPSIZE_X, MAPSIZE_Y, NE, NW, level_cache::outside_cache, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_east, point_north, point_south, point_west, point_zero, SE, weather_type::sight_penalty, SW, level_cache::transparency_cache, weather_manager::weather_id, point::x, point::y, and zlevels.

Referenced by generate_lightmap().

◆ build_transparency_cache()

bool map::build_transparency_cache ( int zlev )

protected

Definition at line 105 of file lightmap.cpp.

{
    auto &map_cache = get_cache( zlev );
    auto &transparency_cache = map_cache.transparency_cache;
    auto &outside_cache = map_cache.outside_cache;
 
    if( map_cache.transparency_cache_dirty.none() ) {
        return false;
    }
 
    std::set<tripoint> vehicles_processed;
 
    // if true, all submaps are invalid (can use batch init)
    bool rebuild_all = map_cache.transparency_cache_dirty.all();
 
    if( rebuild_all ) {
        // Default to just barely not transparent.
        std::uninitialized_fill_n( &transparency_cache[0][0], MAPSIZE_X * MAPSIZE_Y,
                                   static_cast<float>( LIGHT_TRANSPARENCY_OPEN_AIR ) );
    }
 
    const float sight_penalty = get_weather().weather_id->sight_penalty;
 
    if( sight_penalty != 1.0f &&
        LIGHT_TRANSPARENCY_OPEN_AIR * sight_penalty != weather_transparency_lookup.transparency ) {
        weather_transparency_lookup.reset( LIGHT_TRANSPARENCY_OPEN_AIR * sight_penalty );
    }
 
    // Traverse the submaps in order
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const auto cur_submap = get_submap_at_grid( {smx, smy, zlev} );
 
            const point sm_offset = sm_to_ms_copy( point( smx, smy ) );
 
            if( !rebuild_all && !map_cache.transparency_cache_dirty[smx * MAPSIZE + smy] ) {
                continue;
            }
 
            // calculates transparency of a single tile
            // x,y - coords in map local coords
            auto calc_transp = [&]( point  p ) {
                const point sp = p - sm_offset;
                float value = LIGHT_TRANSPARENCY_OPEN_AIR;
 
                if( !( cur_submap->get_ter( sp ).obj().transparent &&
                       cur_submap->get_furn( sp ).obj().transparent ) ) {
                    return LIGHT_TRANSPARENCY_SOLID;
                }
                if( outside_cache[p.x][p.y] ) {
                    // FIXME: Places inside vehicles haven't been marked as
                    // inside yet so this is incorrectly penalising for
                    // weather in vehicles.
                    value *= sight_penalty;
                }
                for( const auto &fld : cur_submap->get_field( sp ) ) {
                    const field_entry &cur = fld.second;
                    if( cur.is_transparent() ) {
                        continue;
                    }
                    // Fields are either transparent or not, however we want some to be translucent
                    value = value * cur.translucency();
                }
                // TODO: [lightmap] Have glass reduce light as well
                return value;
            };
 
            if( cur_submap->is_uniform ) {
                float value = calc_transp( sm_offset );
                // if rebuild_all==true all values were already set to LIGHT_TRANSPARENCY_OPEN_AIR
                if( !rebuild_all || value != LIGHT_TRANSPARENCY_OPEN_AIR ) {
                    for( int sx = 0; sx < SEEX; ++sx ) {
                        // init all sy indices in one go
                        std::uninitialized_fill_n( &transparency_cache[sm_offset.x + sx][sm_offset.y], SEEY, value );
                    }
                }
            } else {
                for( int sx = 0; sx < SEEX; ++sx ) {
                    const int x = sx + sm_offset.x;
                    for( int sy = 0; sy < SEEY; ++sy ) {
                        const int y = sy + sm_offset.y;
                        transparency_cache[x][y] = calc_transp( { x, y } );
 
                        //Nudge things towards fast paths
                        if( std::fabs( transparency_cache[x][y] - openair_transparency_lookup.transparency ) <= 0.0001 ) {
                            transparency_cache[x][y] = openair_transparency_lookup.transparency;
                        } else if( std::fabs( transparency_cache[x][y] - weather_transparency_lookup.transparency ) <=
                                   0.0001 ) {
                            transparency_cache[x][y] = weather_transparency_lookup.transparency;
                        }
                    }
                }
            }
        }
    }
    map_cache.transparency_cache_dirty.reset();
    return true;
}

References units::fabs(), get_cache(), get_submap_at_grid(), get_weather(), field_entry::is_transparent(), LIGHT_TRANSPARENCY_OPEN_AIR, LIGHT_TRANSPARENCY_SOLID, MAPSIZE, MAPSIZE_X, MAPSIZE_Y, my_MAPSIZE, openair_transparency_lookup, SEEX, SEEY, weather_type::sight_penalty, sm_to_ms_copy(), sx, sy, field_entry::translucency(), weather_manager::weather_id, and weather_transparency_lookup.

Referenced by build_map_cache().

◆ build_vision_transparency_cache()

bool map::build_vision_transparency_cache ( const Character & player )

protected

Definition at line 204 of file lightmap.cpp.

{
    const tripoint &p = player.pos();
 
    bool dirty = false;
 
    if( player.movement_mode_is( CMM_CROUCH ) ) {
 
        const auto check_vehicle_coverage = []( const vehicle * veh, point  p ) -> bool {
            return veh->obstacle_at_position( p ) == -1 && ( veh->part_with_feature( p,  "AISLE", true ) != -1 || veh->part_with_feature( p,  "PROTRUSION", true ) != -1 );
        };
 
        const optional_vpart_position player_vp = veh_at( p );
 
        point player_mount;
        if( player_vp ) {
            player_mount = player_vp->vehicle().tripoint_to_mount( p );
        }
 
        int i = 0;
        for( point adjacent : eight_adjacent_offsets ) {
            vision_transparency_cache[i] = VISION_ADJUST_NONE;
 
            // If we're crouching behind an obstacle, we can't see past it.
            if( coverage( adjacent + p ) >= 30 ) {
                dirty = true;
                vision_transparency_cache[i] = VISION_ADJUST_SOLID;
            } else {
                if( std::find( four_diagonal_offsets.begin(), four_diagonal_offsets.end(),
                               adjacent ) != four_diagonal_offsets.end() ) {
                    const optional_vpart_position adjacent_vp = veh_at( p + adjacent );
 
                    point adjacent_mount;
                    if( adjacent_vp ) {
                        adjacent_mount = adjacent_vp->vehicle().tripoint_to_mount( p );
                    }
 
                    if( ( player_vp &&
                          !player_vp->vehicle().check_rotated_intervening( player_mount,
                                  player_vp->vehicle().tripoint_to_mount( p + adjacent ),
                                  check_vehicle_coverage ) )
                        || ( adjacent_vp && ( !player_vp ||  &( player_vp->vehicle() ) != &( adjacent_vp->vehicle() ) ) &&
                             !adjacent_vp->vehicle().check_rotated_intervening( adjacent_vp->vehicle().tripoint_to_mount(
                                         p ), adjacent_vp->vehicle().tripoint_to_mount( p + adjacent ),
                                     check_vehicle_coverage ) ) ) {
                        dirty = true;
                        vision_transparency_cache[ i ] = VISION_ADJUST_HIDDEN;
                    }
                }
            }
 
            i++;
        }
    } else {
        std::fill_n( &vision_transparency_cache[0], 8, VISION_ADJUST_NONE );
    }
    return dirty;
}

References CMM_CROUCH, coverage(), eight_adjacent_offsets, detail::find(), four_diagonal_offsets, Character::movement_mode_is(), vehicle::obstacle_at_position(), vehicle::part_with_feature(), Character::pos(), veh_at(), VISION_ADJUST_HIDDEN, VISION_ADJUST_NONE, VISION_ADJUST_SOLID, and vision_transparency_cache.

Referenced by build_map_cache().

◆ burn_body_part()

int map::burn_body_part	(	player &	u,
		field_entry &	cur,
		body_part	bp,
		int	scale
	)

private

Definition at line 125 of file map_field.cpp.

{
    int total_damage = 0;
    const int intensity = cur.get_field_intensity();
    const int damage = rng( 1, ( scale + intensity ) / 2 );
    // A bit ugly, but better than being annoyed by acid when in hazmat
    if( u.get_armor_type( DT_ACID, convert_bp( bp ) ) < damage ) {
        const dealt_damage_instance ddi = u.deal_damage( nullptr, convert_bp( bp ).id(),
                                          damage_instance( DT_ACID, damage ) );
        total_damage += ddi.total_damage();
    }
    // Represents acid seeping in rather than being splashed on
    u.add_env_effect( effect_corroding, bp, 2 + intensity, time_duration::from_turns( rng( 2,
                      1 + intensity ) ), bp, 0 );
    return total_damage;
}

References Creature::add_env_effect(), convert_bp(), Character::deal_damage(), DT_ACID, effect_corroding, time_duration::from_turns(), Character::get_armor_type(), field_entry::get_field_intensity(), rng(), and dealt_damage_instance::total_damage().

Referenced by player_in_field().

◆ calc_max_populated_zlev()

int map::calc_max_populated_zlev ( )

private

Caclulate the greatest populated zlevel in the loaded submaps and save in the level cache.

fills the map::max_populated_zlev and returns it

Returns: max_populated_zlev value

Definition at line 9145 of file map.cpp.

{
    // cache is filled and valid, skip recalculation
    if( max_populated_zlev && max_populated_zlev->first == get_abs_sub() ) {
        return max_populated_zlev->second;
    }
 
    // We'll assume ground level is populated
    int max_z = 0;
 
    for( int sz = 1; sz <= OVERMAP_HEIGHT; sz++ ) {
        bool level_done = false;
        for( int sx = 0; sx < my_MAPSIZE; sx++ ) {
            for( int sy = 0; sy < my_MAPSIZE; sy++ ) {
                const submap *sm = get_submap_at_grid( tripoint( sx, sy, sz ) );
                if( !sm->is_uniform ) {
                    max_z = sz;
                    level_done = true;
                    break;
                }
            }
            if( level_done ) {
                break;
            }
        }
    }
 
    max_populated_zlev = std::pair<tripoint, int>( get_abs_sub(), max_z );
    return max_z;
}

References get_abs_sub(), get_submap_at_grid(), max_populated_zlev, my_MAPSIZE, OVERMAP_HEIGHT, coords::sm, sx, and sy.

Referenced by build_sunlight_cache().

◆ can_move_furniture()

bool map::can_move_furniture	(	const tripoint &	pos,
		player *	p = `nullptr`
	)

Strength determines what furniture the player can move

Definition at line 1510 of file map.cpp.

{
    if( !p ) {
        return false;
    }
    const furn_t &furniture_type = furn( pos ).obj();
    int required_str = furniture_type.move_str_req;
 
    // Object can not be moved (or nothing there)
    if( required_str < 0 ) {
        return false;
    }
 
    ///\EFFECT_STR determines what furniture the player can move
    int adjusted_str = p->str_cur;
    if( p->is_mounted() ) {
        auto mons = p->mounted_creature.get();
        if( mons->has_flag( MF_RIDEABLE_MECH ) && mons->mech_str_addition() != 0 ) {
            adjusted_str = mons->mech_str_addition();
        }
    }
    return adjusted_str >= required_str;
}

References furn(), Character::is_mounted(), MF_RIDEABLE_MECH, Character::mounted_creature, furn_t::move_str_req, int_id< T >::obj(), wrapped_vehicle::pos, and Character::str_cur.

◆ can_put_items() [1/2]

bool map::can_put_items ( const tripoint & p ) const

Definition at line 2380 of file map.cpp.

{
    if( can_put_items_ter_furn( p ) ) {
        return true;
    }
    const optional_vpart_position vp = veh_at( p );
    return static_cast<bool>( vp.part_with_feature( "CARGO", true ) );
}

References can_put_items_ter_furn(), optional_vpart_position::part_with_feature(), and veh_at().

Referenced by can_put_items(), and game::place_player().

◆ can_put_items() [2/2]

bool map::can_put_items ( point p ) const

inline

Definition at line 909 of file map.h.

                                            {
            return can_put_items( tripoint( p, abs_sub.z ) );
        }

References abs_sub, can_put_items(), and tripoint::z.

◆ can_put_items_ter_furn() [1/2]

bool map::can_put_items_ter_furn ( const tripoint & p ) const

Definition at line 2389 of file map.cpp.

{
    return !has_flag( "NOITEM", p ) && !has_flag( "SEALED", p );
}

References has_flag().

Referenced by can_put_items(), and can_put_items_ter_furn().

◆ can_put_items_ter_furn() [2/2]

bool map::can_put_items_ter_furn ( point p ) const

inline

Definition at line 914 of file map.h.

                                                     {
            return can_put_items_ter_furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, can_put_items_ter_furn(), and tripoint::z.

◆ can_see_trap_at()

bool map::can_see_trap_at	(	const tripoint &	p,
		const Character &	c
	)		const

See trap::can_see, which is called for the trap here.

Definition at line 5253 of file map.cpp.

{
    return tr_at( p ).can_see( p, c );
}

References c, trap::can_see(), and tr_at().

◆ check_and_set_seen_cache()

bool map::check_and_set_seen_cache ( const tripoint & p ) const

Definition at line 8959 of file map.cpp.

{
    std::bitset<MAPSIZE_X *MAPSIZE_Y> &memory_seen_cache =
        get_cache( p.z ).map_memory_seen_cache;
    if( !memory_seen_cache[ static_cast<size_t>( p.x + p.y * MAPSIZE_Y ) ] ) {
        memory_seen_cache.set( static_cast<size_t>( p.x + p.y * MAPSIZE_Y ) );
        return true;
    }
    return false;
}

References get_cache(), level_cache::map_memory_seen_cache, MAPSIZE_Y, tripoint::x, tripoint::y, and tripoint::z.

Referenced by draw_maptile().

◆ check_seen_cache()

bool map::check_seen_cache ( const tripoint & p ) const

Definition at line 8952 of file map.cpp.

{
    std::bitset<MAPSIZE_X *MAPSIZE_Y> &memory_seen_cache =
        get_cache( p.z ).map_memory_seen_cache;
    return !memory_seen_cache[ static_cast<size_t>( p.x + p.y * MAPSIZE_Y ) ];
}

References get_cache(), level_cache::map_memory_seen_cache, MAPSIZE_Y, tripoint::x, tripoint::y, and tripoint::z.

◆ check_submap_active_item_consistency()

std::vector< tripoint > map::check_submap_active_item_consistency ( )

Definition at line 4674 of file map.cpp.

{
    std::vector<tripoint> result;
    for( int z = -OVERMAP_DEPTH; z < OVERMAP_HEIGHT; ++z ) {
        for( int x = 0; x < MAPSIZE; ++x ) {
            for( int y = 0; y < MAPSIZE; ++y ) {
                tripoint p( x, y, z );
                submap *s = get_submap_at_grid( p );
                bool has_active_items = !s->active_items.get().empty();
                bool map_has_active_items = submaps_with_active_items.count( p + abs_sub.xy() );
                if( has_active_items != map_has_active_items ) {
                    result.push_back( p + abs_sub.xy() );
                }
            }
        }
    }
    for( const tripoint &p : submaps_with_active_items ) {
        tripoint rel = p - abs_sub.xy();
        half_open_rectangle<point> map( point_zero, point( MAPSIZE, MAPSIZE ) );
        if( !map.contains( rel.xy() ) ) {
            result.push_back( p );
        }
    }
    return result;
}

References abs_sub, submap::active_items, active_item_cache::get(), get_submap_at_grid(), map(), MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, submaps_with_active_items, and tripoint::xy().

◆ check_vehicle_zones()

bool map::check_vehicle_zones ( int zlev )

Definition at line 989 of file map.cpp.

{
    for( auto veh : get_cache( zlev ).zone_vehicles ) {
        if( veh->zones_dirty ) {
            return true;
        }
    }
    return false;
}

References get_cache().

◆ clear_path()

bool map::clear_path	(	const tripoint &	f,
		const tripoint &	t,
		int	range,
		int	cost_min,
		int	cost_max
	)		const

Check whether there's a direct line of sight between F and T with the additional movecost restraints.

Checks two things:

The sees() algorithm between F and T
That moving over the line of sight would have a move_cost between cost_min and cost_max.

Definition at line 6535 of file map.cpp.

{
    // Ugly `if` for now
    if( !fov_3d && f.z != t.z ) {
        return false;
    }
 
    if( f.z == t.z ) {
        if( ( range >= 0 && range < rl_dist( f.xy(), t.xy() ) ) ||
            !inbounds( t ) ) {
            return false; // Out of range!
        }
        bool is_clear = true;
        point last_point = f.xy();
        bresenham( f.xy(), t.xy(), 0,
        [this, &is_clear, cost_min, cost_max, &t, &last_point]( point  new_point ) {
            // Exit before checking the last square, it's still reachable even if it is an obstacle.
            if( new_point.x == t.x && new_point.y == t.y ) {
                return false;
            }
 
            const int cost = this->move_cost( new_point );
            if( cost < cost_min || cost > cost_max ||
                obstructed_by_vehicle_rotation( tripoint( last_point, t.z ), tripoint( new_point,
                                                t.z ) ) ) {
                is_clear = false;
                return false;
            }
 
            last_point = new_point;
            return true;
        } );
        return is_clear;
    }
 
    if( ( range >= 0 && range < rl_dist( f, t ) ) ||
        !inbounds( t ) ) {
        return false; // Out of range!
    }
    bool is_clear = true;
    tripoint last_point = f;
    bresenham( f, t, 0, 0,
    [this, &is_clear, cost_min, cost_max, t, &last_point]( const tripoint & new_point ) {
        // Exit before checking the last square, it's still reachable even if it is an obstacle.
        if( new_point == t ) {
            return false;
        }
 
        // We have to check a weird case where the move is both vertical and horizontal
        if( new_point.z == last_point.z ) {
            const int cost = move_cost( new_point );
            if( cost < cost_min || cost > cost_max ||
                obstructed_by_vehicle_rotation( last_point, new_point ) ) {
                is_clear = false;
                return false;
            }
        } else {
            bool this_clear = false;
            const int max_z = std::max( new_point.z, last_point.z );
            if( !has_floor_or_support( {new_point.xy(), max_z} ) ) {
                const int cost = move_cost( {new_point.xy(), last_point.z} );
                if( cost > cost_min && cost < cost_max &&
                    !obstructed_by_vehicle_rotation( last_point, new_point ) ) {
                    this_clear = true;
                }
            }
 
            if( !this_clear && has_floor_or_support( {last_point.xy(), max_z} ) ) {
                const int cost = move_cost( {last_point.xy(), new_point.z} );
                if( cost > cost_min && cost < cost_max &&
                    !obstructed_by_vehicle_rotation( last_point, new_point ) ) {
                    this_clear = true;
                }
            }
 
            if( !this_clear ) {
                is_clear = false;
                return false;
            }
        }
 
        last_point = new_point;
        return true;
    } );
    return is_clear;
}

References bresenham(), fov_3d, inbounds(), obstructed_by_vehicle_rotation(), range, rl_dist(), tripoint::xy(), and tripoint::z.

Referenced by process_fields_in_submap(), and game::start_game().

◆ clear_spawns()

void map::clear_spawns ( )

Definition at line 7864 of file map.cpp.

{
    for( auto &smap : grid ) {
        smap->spawns.clear();
    }
}

References grid.

Referenced by defense_game::init_map().

◆ clear_traps()

void map::clear_traps ( )

Definition at line 7871 of file map.cpp.

{
    for( auto &smap : grid ) {
        for( int x = 0; x < SEEX; x++ ) {
            for( int y = 0; y < SEEY; y++ ) {
                const point p( x, y );
                smap->set_trap( p, tr_null );
            }
        }
    }
 
    // Forget about all trap locations.
    for( auto &i : traplocs ) {
        i.clear();
    }
}

References grid, SEEX, SEEY, tr_null, and traplocs.

Referenced by defense_game::init_map().

◆ clear_vehicle_cache()

void map::clear_vehicle_cache ( )

Definition at line 373 of file map.cpp.

{
    const int zmin = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int zmax = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int zlev = zmin; zlev <= zmax; zlev++ ) {
        level_cache &ch = get_cache( zlev );
        while( !ch.veh_cached_parts.empty() ) {
            const auto part = ch.veh_cached_parts.begin();
            const auto &p = part->first;
            if( inbounds( p ) ) {
                ch.veh_exists_at[p.x][p.y] = false;
            }
            ch.veh_cached_parts.erase( part );
        }
        ch.veh_in_active_range = false;
    }
}

References abs_sub, get_cache(), inbounds(), OVERMAP_DEPTH, OVERMAP_HEIGHT, level_cache::veh_cached_parts, level_cache::veh_exists_at, level_cache::veh_in_active_range, tripoint::z, and zlevels.

Referenced by game::place_player_overmap(), reset_vehicle_cache(), rotate(), shift(), and game::vertical_shift().

◆ clear_vehicle_list()

void map::clear_vehicle_list ( int zlev )

Definition at line 391 of file map.cpp.

{
    auto &ch = get_cache( zlev );
    ch.vehicle_list.clear();
    ch.zone_vehicles.clear();
 
    last_full_vehicle_list_dirty = true;
}

References get_cache(), and last_full_vehicle_list_dirty.

Referenced by game::place_player_overmap(), rotate(), and shift().

◆ clear_vehicle_point_from_cache()

void map::clear_vehicle_point_from_cache	(	vehicle *	veh,
		const tripoint &	pt
	)

Definition at line 355 of file map.cpp.

{
    if( veh == nullptr ) {
        debugmsg( "Tried to clear null vehicle from cache" );
        return;
    }
 
    level_cache &ch = get_cache( pt.z );
    if( inbounds( pt ) ) {
        ch.veh_exists_at[pt.x][pt.y] = false;
    }
    auto it = ch.veh_cached_parts.find( pt );
    if( it != ch.veh_cached_parts.end() && it->second.first == veh ) {
        ch.veh_cached_parts.erase( it );
    }
 
}

References debugmsg, get_cache(), inbounds(), level_cache::veh_cached_parts, level_cache::veh_exists_at, tripoint::x, tripoint::y, and tripoint::z.

Referenced by veh_interact::complete_vehicle().

◆ climb_difficulty()

int map::climb_difficulty ( const tripoint & p ) const

Checks 3x3 block centered on p for terrain to climb.

Returns: Difficulty of climbing check from point p.

Definition at line 2034 of file map.cpp.

{
    if( p.z > OVERMAP_HEIGHT || p.z < -OVERMAP_DEPTH ) {
        debugmsg( "climb_difficulty on out of bounds point: %d, %d, %d", p.x, p.y, p.z );
        return INT_MAX;
    }
 
    int best_difficulty = INT_MAX;
    int blocks_movement = 0;
    if( has_flag( "LADDER", p ) ) {
        // Really easy, but you have to stand on the tile
        return 1;
    } else if( has_flag( TFLAG_RAMP, p ) || has_flag( TFLAG_RAMP_UP, p ) ||
               has_flag( TFLAG_RAMP_DOWN, p ) ) {
        // We're on something stair-like, so halfway there already
        best_difficulty = 7;
    }
 
    for( const auto &pt : points_in_radius( p, 1 ) ) {
        if( impassable_ter_furn( pt ) ) {
            // TODO: Non-hardcoded climbability
            best_difficulty = std::min( best_difficulty, 10 );
            blocks_movement++;
        } else if( veh_at( pt ) ) {
            // Vehicle tiles are quite good for climbing
            // TODO: Penalize spiked parts?
            best_difficulty = std::min( best_difficulty, 7 );
        }
 
        if( best_difficulty > 5 && has_flag( "CLIMBABLE", pt ) ) {
            best_difficulty = 5;
        }
    }
 
    // TODO: Make this more sensible - check opposite sides, not just movement blocker count
    return std::max( 0, best_difficulty - blocks_movement );
}

References debugmsg, has_flag(), impassable_ter_furn(), OVERMAP_DEPTH, OVERMAP_HEIGHT, points_in_radius(), TFLAG_RAMP, TFLAG_RAMP_DOWN, TFLAG_RAMP_UP, veh_at(), tripoint::x, tripoint::y, and tripoint::z.

◆ clip_to_bounds() [1/3]

void map::clip_to_bounds	(	int &	x,
		int &	y
	)		const

Definition at line 9088 of file map.cpp.

{
    if( x < 0 ) {
        x = 0;
    } else if( x >= SEEX * my_MAPSIZE ) {
        x = SEEX * my_MAPSIZE - 1;
    }
 
    if( y < 0 ) {
        y = 0;
    } else if( y >= SEEY * my_MAPSIZE ) {
        y = SEEY * my_MAPSIZE - 1;
    }
}

References my_MAPSIZE, SEEX, and SEEY.

◆ clip_to_bounds() [2/3]

void map::clip_to_bounds	(	int &	x,
		int &	y,
		int &	z
	)		const

Definition at line 9103 of file map.cpp.

{
    clip_to_bounds( x, y );
    if( z < -OVERMAP_DEPTH ) {
        z = -OVERMAP_DEPTH;
    } else if( z > OVERMAP_HEIGHT ) {
        z = OVERMAP_HEIGHT;
    }
}

References clip_to_bounds(), OVERMAP_DEPTH, and OVERMAP_HEIGHT.

◆ clip_to_bounds() [3/3]

void map::clip_to_bounds ( tripoint & p ) const

Clips the coordinates of p to fit the map bounds.

Definition at line 9083 of file map.cpp.

{
    clip_to_bounds( p.x, p.y, p.z );
}

References clip_to_bounds(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by MapgenRemovePartHandler::add_item_or_charges(), clip_to_bounds(), and route().

◆ close_door()

bool map::close_door	(	const tripoint &	p,
		bool	inside,
		bool	check_only
	)

Definition at line 4094 of file map.cpp.

{
    if( has_flag( "OPENCLOSE_INSIDE", p ) && !inside ) {
        return false;
    }
 
    const auto &ter = this->ter( p ).obj();
    const auto &furn = this->furn( p ).obj();
    if( ter.close && !furn.id ) {
        if( !check_only ) {
            sounds::sound( p, 10, sounds::sound_t::movement, _( "swish" ), true,
                           "close_door", ter.id.str() );
            ter_set( p, ter.close );
        }
        return true;
    } else if( furn.close ) {
        if( !check_only ) {
            sounds::sound( p, 10, sounds::sound_t::movement, _( "swish" ), true,
                           "close_door", furn.id.str() );
            furn_set( p, furn.close );
        }
        return true;
    }
    return false;
}

References _, furn(), furn_set(), has_flag(), int_id< T >::id(), sounds::movement, int_id< T >::obj(), sounds::sound(), string_id< T >::str(), ter(), and ter_set().

Referenced by doors::close_door(), and game::try_get_right_click_action().

◆ collapse_at()

void map::collapse_at	(	const tripoint &	p,
		bool	silent,
		bool	was_supporting = `false`,
		bool	destroy_pos = `true`
	)

Causes a collapse at p, such as from destroying a wall.

Definition at line 2961 of file map.cpp.

{
    const bool supports = was_supporting || has_flag( TFLAG_SUPPORTS_ROOF, p );
    const bool wall = was_supporting || has_flag( TFLAG_WALL, p );
    // don't bash again if the caller already bashed here
    if( destroy_pos ) {
        destroy( p, silent );
        crush( p );
        make_rubble( p );
    }
    const bool still_supports = has_flag( TFLAG_SUPPORTS_ROOF, p );
 
    // If something supporting the roof collapsed, see what else collapses
    if( supports && !still_supports ) {
        for( const tripoint &t : points_in_radius( p, 1 ) ) {
            // If z-levels are off, tz == t, so we end up skipping a lot of stuff to avoid bugs.
            const tripoint &tz = tripoint( t.xy(), t.z + 1 );
            // if nothing above us had the chance of collapsing, move on
            if( !one_in( collapse_check( tz ) ) ) {
                continue;
            }
            // if a wall collapses, walls without support from below risk collapsing and
            //propagate the collapse upwards
            if( zlevels && wall && p == t && has_flag( TFLAG_WALL, tz ) ) {
                collapse_at( tz, silent );
            }
            // floors without support from below risk collapsing into open air and can propagate
            // the collapse horizontally but not vertically
            if( p != t && ( has_flag( TFLAG_SUPPORTS_ROOF, t ) && has_flag( TFLAG_COLLAPSES, t ) ) ) {
                collapse_at( t, silent );
            }
            // this tile used to support a roof, now it doesn't, which means there is only
            // open air above us
            if( zlevels ) {
                ter_set( tz, t_open_air );
                furn_set( tz, f_null );
                propagate_suspension_check( tz );
            }
        }
    }
    // it would be great to check if collapsing ceilings smashed through the floor, but
    // that's not handled for now
}

References collapse_at(), collapse_check(), crush(), destroy(), f_null, furn_set(), has_flag(), make_rubble(), one_in(), points_in_radius(), propagate_suspension_check(), silent, t_open_air, ter_set(), TFLAG_COLLAPSES, TFLAG_SUPPORTS_ROOF, TFLAG_WALL, and zlevels.

Referenced by bash_ter_success(), collapse_at(), and talk_function::loot_building().

◆ collapse_check()

int map::collapse_check ( const tripoint & p )

Checks if a square should collapse, returns the X for the one_in(X) collapse chance.

Definition at line 2912 of file map.cpp.

{
    const bool collapses = has_flag( TFLAG_COLLAPSES, p );
    const bool supports_roof = has_flag( TFLAG_SUPPORTS_ROOF, p );
 
    int num_supports = p.z == -OVERMAP_DEPTH ? 0 : -5;
    // if there's support below, things are less likely to collapse
    if( p.z > -OVERMAP_DEPTH ) {
        const tripoint &pbelow = tripoint( p.xy(), p.z - 1 );
        for( const tripoint &tbelow : points_in_radius( pbelow, 1 ) ) {
            if( has_flag( TFLAG_SUPPORTS_ROOF, pbelow ) ) {
                num_supports += 1;
                if( has_flag( TFLAG_WALL, pbelow ) ) {
                    num_supports += 2;
                }
                if( tbelow == pbelow ) {
                    num_supports += 2;
                }
            }
        }
    }
 
    for( const tripoint &t : points_in_radius( p, 1 ) ) {
        if( p == t ) {
            continue;
        }
 
        if( collapses ) {
            if( has_flag( TFLAG_COLLAPSES, t ) ) {
                num_supports++;
            } else if( has_flag( TFLAG_SUPPORTS_ROOF, t ) ) {
                num_supports += 2;
            }
        } else if( supports_roof ) {
            if( has_flag( TFLAG_SUPPORTS_ROOF, t ) ) {
                if( has_flag( TFLAG_WALL, t ) ) {
                    num_supports += 4;
                } else if( !has_flag( TFLAG_COLLAPSES, t ) ) {
                    num_supports += 3;
                }
            }
        }
    }
 
    return 1.7 * num_supports;
}

References has_flag(), OVERMAP_DEPTH, points_in_radius(), TFLAG_COLLAPSES, TFLAG_SUPPORTS_ROOF, TFLAG_WALL, tripoint::xy(), and tripoint::z.

Referenced by collapse_at().

◆ collapse_invalid_suspension()

void map::collapse_invalid_suspension ( const tripoint & point )

Triggers a recursive collapse of suspended tiles based on their support validity.

Definition at line 3015 of file map.cpp.

{
    if( !is_suspension_valid( point ) ) {
        ter_set( point, t_open_air );
        furn_set( point, f_null );
 
        propagate_suspension_check( point );
    }
}

References f_null, furn_set(), is_suspension_valid(), propagate_suspension_check(), t_open_air, and ter_set().

Referenced by drop_everything(), and propagate_suspension_check().

◆ combined_movecost()

int map::combined_movecost	(	const tripoint &	from,
		const tripoint &	to,
		const vehicle *	ignored_vehicle = `nullptr`,
		int	modifier = `0`,
		bool	flying = `false`,
		bool	via_ramp = `false`
	)		const

Cost to move out of one tile and into the next.

Returns: The cost in turns to move out of tripoint from and into to

Definition at line 1903 of file map.cpp.

{
    const int mults[4] = { 0, 50, 71, 100 };
    const int cost1 = move_cost( from, ignored_vehicle );
    const int cost2 = move_cost( to, ignored_vehicle );
    // Multiply cost depending on the number of differing axes
    // 0 if all axes are equal, 100% if only 1 differs, 141% for 2, 200% for 3
    size_t match = trigdist ? ( from.x != to.x ) + ( from.y != to.y ) + ( from.z != to.z ) : 1;
    if( flying || from.z == to.z ) {
        return ( cost1 + cost2 + modifier ) * mults[match] / 2;
    }
 
    // Inter-z-level movement by foot (not flying)
    if( !valid_move( from, to, false, via_ramp ) ) {
        return 0;
    }
 
    // TODO: Penalize for using stairs
    return ( cost1 + cost2 + modifier ) * mults[match] / 2;
}

References move_cost(), trigdist, valid_move(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by game::walk_move().

◆ computer_at()

computer * map::computer_at ( const tripoint & p )

Definition at line 5682 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return nullptr;
    }
 
    point l;
    submap *const sm = get_submap_at( p, l );
    return sm->get_computer( l );
}

References get_submap_at(), inbounds(), and coords::sm.

Referenced by mission_start::reveal_lab_train_depot(), and game::use_computer().

◆ copy_grid()

void map::copy_grid	(	const tripoint &	to,
		const tripoint &	from
	)

protected

Definition at line 7649 of file map.cpp.

{
    const auto smap = get_submap_at_grid( from );
    setsubmap( get_nonant( to ), smap );
    for( auto &it : smap->vehicles ) {
        it->sm_pos = to;
    }
}

References get_nonant(), get_submap_at_grid(), and setsubmap().

Referenced by shift().

◆ could_see_items() [1/2]

bool map::could_see_items	(	const tripoint &	p,
		const Creature &	who
	)		const

Check if the creature could see items at p if there were any items.

This is similar to sees_some_items, but it does not check that there are actually any items.

Definition at line 4867 of file map.cpp.

{
    return could_see_items( p, who.pos() );
}

References could_see_items(), and Creature::pos().

Referenced by could_see_items(), game::print_items_info(), and sees_some_items().

◆ could_see_items() [2/2]

bool map::could_see_items	(	const tripoint &	p,
		const tripoint &	from
	)		const

Definition at line 4872 of file map.cpp.

{
    static const std::string container_string( "CONTAINER" );
    const bool container = has_flag_ter_or_furn( container_string, p );
    const bool sealed = has_flag_ter_or_furn( TFLAG_SEALED, p );
    if( sealed && container ) {
        // never see inside of sealed containers
        return false;
    }
    if( container ) {
        // can see inside of containers if adjacent or
        // on top of the container
        return ( std::abs( p.x - from.x ) <= 1 &&
                 std::abs( p.y - from.y ) <= 1 &&
                 std::abs( p.z - from.z ) <= 1 );
    }
    return true;
}

References has_flag_ter_or_furn(), TFLAG_SEALED, tripoint::x, tripoint::y, and tripoint::z.

◆ coverage()

int map::coverage ( const tripoint & p ) const

Returns coverage value of the tile.

Definition at line 6384 of file map.cpp.

{
    if( const auto obstacle_f = furn( p ) ) {
        return obstacle_f->coverage;
    }
    if( const auto vp = veh_at( p ) ) {
        if( vp->obstacle_at_part() ) {
            return 60;
        } else if( !vp->part_with_feature( VPFLAG_AISLE, true ) &&
                   !vp->part_with_feature( "PROTRUSION", true ) ) {
            return 45;
        }
    }
    return ter( p )->coverage;
}

References map_data_common_t::coverage, furn(), ter(), veh_at(), and VPFLAG_AISLE.

Referenced by build_vision_transparency_cache(), and game::print_terrain_info().

◆ create_anomaly() [1/2]

void map::create_anomaly	(	const tripoint &	p,
		artifact_natural_property	prop,
		bool	create_rubble = `true`
	)

Definition at line 6158 of file mapgen.cpp.

{
    // TODO: Z
    point c( cp.xy() );
    if( create_rubble ) {
        rough_circle( this, t_dirt, c, 11 );
        rough_circle_furn( this, f_rubble, c, 5 );
        furn_set( c, f_null );
    }
    switch( prop ) {
        case ARTPROP_WRIGGLING:
        case ARTPROP_MOVING:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble ) {
                        add_field( {i, j, abs_sub.z}, fd_push_items, 1 );
                    }
                }
            }
            break;
 
        case ARTPROP_GLOWING:
        case ARTPROP_GLITTERING:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble && one_in( 2 ) ) {
                        mtrap_set( this, point( i, j ), tr_glow );
                    }
                }
            }
            break;
 
        case ARTPROP_HUMMING:
        case ARTPROP_RATTLING:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble && one_in( 2 ) ) {
                        mtrap_set( this, point( i, j ), tr_hum );
                    }
                }
            }
            break;
 
        case ARTPROP_WHISPERING:
        case ARTPROP_ENGRAVED:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble && one_in( 3 ) ) {
                        mtrap_set( this, point( i, j ), tr_shadow );
                    }
                }
            }
            break;
 
        case ARTPROP_BREATHING:
            for( int i = c.x - 1; i <= c.x + 1; i++ ) {
                for( int j = c.y - 1; j <= c.y + 1; j++ ) {
                    if( i == c.x && j == c.y ) {
                        place_spawns( GROUP_BREATHER_HUB, 1, point( i, j ), point( i, j ), 1,
                                      true );
                    } else {
                        place_spawns( GROUP_BREATHER, 1, point( i, j ), point( i, j ), 1, true );
                    }
                }
            }
            break;
 
        case ARTPROP_DEAD:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble ) {
                        mtrap_set( this, point( i, j ), tr_drain );
                    }
                }
            }
            break;
 
        case ARTPROP_ITCHY:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble ) {
                        set_radiation( point( i, j ), rng( 0, 10 ) );
                    }
                }
            }
            break;
 
        case ARTPROP_ELECTRIC:
        case ARTPROP_CRACKLING:
            add_field( {c, abs_sub.z}, fd_shock_vent, 3 );
            break;
 
        case ARTPROP_SLIMY:
            add_field( {c, abs_sub.z}, fd_acid_vent, 3 );
            break;
 
        case ARTPROP_WARM:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble ) {
                        add_field( {i, j, abs_sub.z}, fd_fire_vent, 1 + ( rl_dist( c, point( i, j ) ) % 3 ) );
                    }
                }
            }
            break;
 
        case ARTPROP_SCALED:
            for( int i = c.x - 5; i <= c.x + 5; i++ ) {
                for( int j = c.y - 5; j <= c.y + 5; j++ ) {
                    if( furn( point( i, j ) ) == f_rubble ) {
                        mtrap_set( this, point( i, j ), tr_snake );
                    }
                }
            }
            break;
 
        case ARTPROP_FRACTAL:
            create_anomaly( c + point( -4, -4 ),
                            static_cast<artifact_natural_property>( rng( ARTPROP_NULL + 1, ARTPROP_MAX - 1 ) ) );
            create_anomaly( c + point( 4, -4 ),
                            static_cast<artifact_natural_property>( rng( ARTPROP_NULL + 1, ARTPROP_MAX - 1 ) ) );
            create_anomaly( c + point( -4, 4 ),
                            static_cast<artifact_natural_property>( rng( ARTPROP_NULL + 1, ARTPROP_MAX - 1 ) ) );
            create_anomaly( c + point( 4, -4 ),
                            static_cast<artifact_natural_property>( rng( ARTPROP_NULL + 1, ARTPROP_MAX - 1 ) ) );
            break;
        default:
            break;
    }
}

References abs_sub, add_field(), ARTPROP_BREATHING, ARTPROP_CRACKLING, ARTPROP_DEAD, ARTPROP_ELECTRIC, ARTPROP_ENGRAVED, ARTPROP_FRACTAL, ARTPROP_GLITTERING, ARTPROP_GLOWING, ARTPROP_HUMMING, ARTPROP_ITCHY, ARTPROP_MAX, ARTPROP_MOVING, ARTPROP_NULL, ARTPROP_RATTLING, ARTPROP_SCALED, ARTPROP_SLIMY, ARTPROP_WARM, ARTPROP_WHISPERING, ARTPROP_WRIGGLING, c, create_anomaly(), f_null, f_rubble, fd_acid_vent, fd_fire_vent, fd_push_items, fd_shock_vent, furn(), furn_set(), GROUP_BREATHER, GROUP_BREATHER_HUB, mtrap_set(), one_in(), place_spawns(), rl_dist(), rng(), rough_circle(), rough_circle_furn(), set_radiation(), t_dirt, tr_drain, tr_glow, tr_hum, tr_shadow, tr_snake, tripoint::xy(), and tripoint::z.

Referenced by create_anomaly(), debug_menu::debug(), draw_lab(), and MapExtras::mx_portal_in().

◆ create_anomaly() [2/2]

void map::create_anomaly	(	point	cp,
		artifact_natural_property	prop,
		bool	create_rubble = `true`
	)

inline

Definition at line 1333 of file map.h.

                                                                                                   {
            create_anomaly( tripoint( cp, abs_sub.z ), prop, create_rubble );
        }

References abs_sub, create_anomaly(), and tripoint::z.

◆ create_burnproducts()

void map::create_burnproducts	(	const tripoint &	p,
		const item &	fuel,
		const units::mass &	burned_mass
	)

Definition at line 97 of file map_field.cpp.

{
    std::vector<material_id> all_mats = fuel.made_of();
    if( all_mats.empty() ) {
        return;
    }
    // Items that are multiple materials are assumed to be equal parts each.
    const units::mass by_weight = burned_mass / all_mats.size();
    for( material_id &mat : all_mats ) {
        for( auto &bp : mat->burn_products() ) {
            itype_id id = bp.first;
            // Spawning the same item as the one that was just burned is pointless
            // and leads to infinite recursion.
            if( fuel.typeId() == id ) {
                continue;
            }
            const float eff = bp.second;
            const int n = std::floor( eff * ( by_weight / id->weight ) );
 
            if( n <= 0 ) {
                continue;
            }
            spawn_item( p, id, n, 1, calendar::turn );
        }
    }
}

References base_camps::id, item::made_of(), spawn_item(), calendar::turn, and item::typeId().

Referenced by MapExtras::burned_ground_parser(), and process_fields_in_submap().

◆ create_hot_air()

void map::create_hot_air	(	const tripoint &	p,
		int	intensity
	)

private

Definition at line 364 of file map_field.cpp.

{
    field_type_id hot_air;
    switch( intensity ) {
        case 1:
            hot_air = fd_hot_air1;
            break;
        case 2:
            hot_air = fd_hot_air2;
            break;
        case 3:
            hot_air = fd_hot_air3;
            break;
        case 4:
            hot_air = fd_hot_air4;
            break;
        default:
            debugmsg( "Tried to spread hot air with intensity %d", intensity );
            return;
    }
 
    for( int counter = 0; counter < 5; counter++ ) {
        tripoint dst( p + point( rng( -1, 1 ), rng( -1, 1 ) ) );
        add_field( dst, hot_air, 1 );
    }
}

References add_field(), debugmsg, fd_hot_air1, fd_hot_air2, fd_hot_air3, fd_hot_air4, and rng().

Referenced by process_fields_in_submap().

◆ creature_in_field()

void map::creature_in_field ( Creature & critter )

Apply field effects to the creature when it's on a square with fields.

Definition at line 1563 of file map_field.cpp.

{
    bool in_vehicle = false;
    bool inside_vehicle = false;
    player *u = critter.as_player();
    if( critter.is_monster() ) {
        monster_in_field( *static_cast<monster *>( &critter ) );
    } else {
        if( u ) {
            in_vehicle = u->in_vehicle;
            // If we are in a vehicle figure out if we are inside (reduces effects usually)
            // and what part of the vehicle we need to deal with.
            if( in_vehicle ) {
                if( const optional_vpart_position vp = veh_at( u->pos() ) ) {
                    if( vp->is_inside() ) {
                        inside_vehicle = true;
                    }
                }
            }
            player_in_field( *u );
        }
    }
 
    field &curfield = get_field( critter.pos() );
    for( auto &field_entry_it : curfield ) {
        field_entry &cur_field_entry = field_entry_it.second;
        if( !cur_field_entry.is_field_alive() ) {
            continue;
        }
        const field_type_id cur_field_id = cur_field_entry.get_field_type();
 
        for( const auto &fe : cur_field_entry.field_effects() ) {
            if( in_vehicle && fe.immune_in_vehicle ) {
                continue;
            }
            if( inside_vehicle && fe.immune_inside_vehicle ) {
                continue;
            }
            if( !inside_vehicle && fe.immune_outside_vehicle ) {
                continue;
            }
            if( in_vehicle && !one_in( fe.chance_in_vehicle ) ) {
                continue;
            }
            if( inside_vehicle && !one_in( fe.chance_inside_vehicle ) ) {
                continue;
            }
            if( !inside_vehicle && !one_in( fe.chance_outside_vehicle ) ) {
                continue;
            }
 
            const effect field_fx = fe.get_effect();
            if( critter.is_immune_field( cur_field_id ) || critter.is_immune_effect( field_fx.get_id() ) ) {
                continue;
            }
            bool effect_added = false;
            if( fe.is_environmental ) {
                effect_added = critter.add_env_effect( fe.id, fe.bp->token, fe.intensity, fe.get_duration() );
            } else {
                effect_added = true;
                critter.add_effect( field_fx );
            }
            if( effect_added ) {
                critter.add_msg_player_or_npc( fe.env_message_type, fe.get_message(), fe.get_message_npc() );
            }
        }
    }
}

References Creature::add_effect(), Creature::add_env_effect(), Creature::add_msg_player_or_npc(), Creature::as_player(), field_entry::field_effects(), get_field(), field_entry::get_field_type(), effect::get_id(), Character::in_vehicle, field_entry::is_field_alive(), Creature::is_immune_effect(), Creature::is_immune_field(), Creature::is_monster(), monster_in_field(), one_in(), player_in_field(), Creature::pos(), Character::pos(), and veh_at().

Referenced by add_field(), game::do_turn(), game::monmove(), and game::place_player().

◆ creature_on_trap()

void map::creature_on_trap	(	Creature &	critter,
		bool	may_avoid = `true`
	)

Apply trap effects to the creature, similar to creature_in_field.

If there is no trap at the creatures location, nothing is done. If the creature can avoid the trap, nothing is done as well. Otherwise the trap is triggered.

Parameters

critter	Creature that just got trapped
may_avoid	If true, the creature tries to avoid the trap (Creature::avoid_trap). If false, the trap is always triggered.

Definition at line 8629 of file map.cpp.

{
    const auto &tr = tr_at( c.pos() );
    if( tr.is_null() ) {
        return;
    }
    // boarded in a vehicle means the player is above the trap, like a flying monster and can
    // never trigger the trap.
    const player *const p = dynamic_cast<const player *>( &c );
    if( p != nullptr && p->in_vehicle ) {
        return;
    }
    if( may_avoid && c.avoid_trap( c.pos(), tr ) ) {
        return;
    }
    tr.trigger( c.pos(), &c );
}

References c, Character::in_vehicle, and tr_at().

Referenced by game::fling_creature(), game::phasing_move(), game::place_player(), and game::vertical_move().

◆ crush()

void map::crush ( const tripoint & p )

Definition at line 3769 of file map.cpp.

{
    player *crushed_player = g->critter_at<player>( p );
 
    if( crushed_player != nullptr ) {
        bool player_inside = false;
        if( crushed_player->in_vehicle ) {
            const optional_vpart_position vp = veh_at( p );
            player_inside = vp && vp->is_inside();
        }
        if( !player_inside ) { //If there's a player at p and he's not in a covered vehicle...
            //This is the roof coming down on top of us, no chance to dodge
            crushed_player->add_msg_player_or_npc( m_bad, _( "You are crushed by the falling debris!" ),
                                                   _( "<npcname> is crushed by the falling debris!" ) );
            // TODO: Make this depend on the ceiling material
            const int dam = rng( 0, 40 );
            // Torso and head take the brunt of the blow
            crushed_player->deal_damage( nullptr, bodypart_id( "head" ), damage_instance( DT_BASH,
                                         dam * .25 ) );
            crushed_player->deal_damage( nullptr, bodypart_id( "torso" ), damage_instance( DT_BASH,
                                         dam * .45 ) );
            // Legs take the next most through transferred force
            crushed_player->deal_damage( nullptr, bodypart_id( "leg_l" ), damage_instance( DT_BASH,
                                         dam * .10 ) );
            crushed_player->deal_damage( nullptr, bodypart_id( "leg_r" ), damage_instance( DT_BASH,
                                         dam * .10 ) );
            // Arms take the least
            crushed_player->deal_damage( nullptr, bodypart_id( "arm_l" ), damage_instance( DT_BASH,
                                         dam * .05 ) );
            crushed_player->deal_damage( nullptr, bodypart_id( "arm_r" ), damage_instance( DT_BASH,
                                         dam * .05 ) );
 
            // Pin whoever got hit
            crushed_player->add_effect( effect_crushed, 1_turns, num_bp );
            crushed_player->check_dead_state();
        }
    }
 
    if( monster *const monhit = g->critter_at<monster>( p ) ) {
        // 25 ~= 60 * .45 (torso)
        monhit->deal_damage( nullptr, bodypart_id( "torso" ), damage_instance( DT_BASH, rng( 0, 25 ) ) );
 
        // Pin whoever got hit
        monhit->add_effect( effect_crushed, 1_turns, num_bp );
        monhit->check_dead_state();
    }
 
    if( const optional_vpart_position vp = veh_at( p ) ) {
        // Arbitrary number is better than collapsing house roof crushing APCs
        vp->vehicle().damage( vp->part_index(), rng( 100, 1000 ), DT_BASH, false );
    }
}

References _, Creature::add_effect(), player::add_msg_player_or_npc(), Creature::check_dead_state(), Character::deal_damage(), DT_BASH, effect_crushed, g, Character::in_vehicle, m_bad, num_bp, rng(), and veh_at().

Referenced by collapse_at().

◆ dangerous_field_at()

bool map::dangerous_field_at ( const tripoint & p )

Definition at line 5525 of file map.cpp.

{
    for( auto &pr : field_at( p ) ) {
        auto &fd = pr.second;
        if( fd.is_dangerous() ) {
            return true;
        }
    }
    return false;
}

References field_at().

◆ decay_cosmetic_fields()

void map::decay_cosmetic_fields	(	const tripoint &	p,
		const time_duration &	time_since_last_actualize
	)

protected

Definition at line 7527 of file map.cpp.

{
    for( auto &pr : field_at( p ) ) {
        auto &fd = pr.second;
        const time_duration hl = fd.get_field_type().obj().half_life;
        if( !fd.decays_on_actualize() || hl <= 0_turns ) {
            continue;
        }
 
        const time_duration added_age = 2 * time_since_last_actualize / rng( 2, 4 );
        fd.mod_field_age( added_age );
        const int intensity_drop = fd.get_field_age() / hl;
        if( intensity_drop > 0 ) {
            fd.set_field_intensity( fd.get_field_intensity() - intensity_drop );
            fd.mod_field_age( -hl * intensity_drop );
        }
    }
}

References field_at(), and rng().

Referenced by actualize().

◆ decay_fields_and_scent()

void map::decay_fields_and_scent ( const time_duration & amount )

Moved here from weather.cpp for speed.

Decays fire, washable fields and scent. Washable fields are decayed only by 1/3 of the amount fire is.

Definition at line 2726 of file map.cpp.

{
    // TODO: Make this happen on all z-levels
 
    // Decay scent separately, so that later we can use field count to skip empty submaps
    g->scent.decay();
 
    // Coordinate code copied from lightmap calculations
    // TODO: Z
    const int smz = abs_sub.z;
    const auto &outside_cache = get_cache_ref( smz ).outside_cache;
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const auto cur_submap = get_submap_at_grid( { smx, smy, smz } );
            int to_proc = cur_submap->field_count;
            if( to_proc < 1 ) {
                if( to_proc < 0 ) {
                    cur_submap->field_count = 0;
                    dbg( DL::Error ) << "map::decay_fields_and_scent: submap at "
                                     << ( abs_sub + tripoint( smx, smy, 0 ) )
                                     << "has " << to_proc << " field_count";
                }
                get_cache( smz ).field_cache.reset( smx + ( smy * MAPSIZE ) );
                // This submap has no fields
                continue;
            }
 
            for( int sx = 0; sx < SEEX; ++sx ) {
                if( to_proc < 1 ) {
                    // This submap had some fields, but all got proc'd already
                    break;
                }
 
                for( int sy = 0; sy < SEEY; ++sy ) {
                    const int x = sx + smx * SEEX;
                    const int y = sy + smy * SEEY;
 
                    field &fields = cur_submap->get_field( { sx, sy} );
                    if( !outside_cache[x][y] ) {
                        to_proc -= fields.field_count();
                        continue;
                    }
 
                    for( auto &fp : fields ) {
                        to_proc--;
                        field_entry &cur = fp.second;
                        const field_type_id type = cur.get_field_type();
                        const int decay_amount_factor =  type.obj().decay_amount_factor;
                        if( decay_amount_factor != 0 ) {
                            const time_duration decay_amount = amount / decay_amount_factor;
                            cur.set_field_age( cur.get_field_age() + decay_amount );
                        }
                    }
                }
            }
 
            if( to_proc > 0 ) {
                cur_submap->field_count = cur_submap->field_count - to_proc;
                dbg( DL::Error ) << "map::decay_fields_and_scent: submap at "
                                 << abs_sub + tripoint( smx, smy, 0 )
                                 << "has " << cur_submap->field_count - to_proc << "fields, but "
                                 << cur_submap->field_count << " field_count";
            }
        }
    }
}

References abs_sub, dbg, Error, level_cache::field_cache, submap::field_count, g, get_cache(), get_cache_ref(), field_entry::get_field_age(), field_entry::get_field_type(), get_submap_at_grid(), MAPSIZE, my_MAPSIZE, level_cache::outside_cache, SEEX, SEEY, field_entry::set_field_age(), sx, sy, type, and tripoint::z.

◆ delete_graffiti()

void map::delete_graffiti ( const tripoint & p )

Definition at line 7959 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    current_submap->delete_graffiti( l );
}

References submap::delete_graffiti(), get_submap_at(), and inbounds().

◆ delete_signage()

void map::delete_signage ( const tripoint & p ) const

Definition at line 4142 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    current_submap->delete_signage( l );
}

References submap::delete_signage(), get_submap_at(), and inbounds().

Referenced by bash_furn_success(), and talk_function::loot_building().

◆ deregister_vehicle_zone()

bool map::deregister_vehicle_zone ( zone_data & zone )

Definition at line 1023 of file map.cpp.

{
    if( const std::optional<vpart_reference> vp = veh_at( getlocal(
                zone.get_start_point() ) ).part_with_feature( "CARGO", false ) ) {
        auto bounds = vp->vehicle().loot_zones.equal_range( vp->mount() );
        for( auto it = bounds.first; it != bounds.second; it++ ) {
            if( &zone == &( it->second ) ) {
                vp->vehicle().loot_zones.erase( it );
                return true;
            }
        }
    }
    return false;
}

References zone_data::get_start_point(), getlocal(), optional_vpart_position::part_with_feature(), and veh_at().

◆ destroy()

void map::destroy	(	const tripoint &	p,
		bool	silent = `false`
	)

Keeps bashing a square until it can't be bashed anymore.

Definition at line 3735 of file map.cpp.

{
    // Break if it takes more than 25 destructions to remove to prevent infinite loops
    // Example: A bashes to B, B bashes to A leads to A->B->A->...
 
    // If we were destroying a floor, allow destroying floors
    // If we were destroying something unpassable, destroy only that
    bool was_impassable = impassable( p );
    int count = 0;
    while( count <= 25
           && bash( p, 999, silent, true ).success
           && ( !was_impassable || impassable( p ) ) ) {
        count++;
    }
}

References bash(), detail::count(), impassable(), silent, and behavior::success.

Referenced by add_vehicle_to_map(), bash(), MapExtras::burned_ground_parser(), collapse_at(), draw_lab(), make_rubble(), MapExtras::mx_crater(), MapExtras::mx_helicopter(), MapExtras::mx_supplydrop(), om_cutdown_trees(), and process_fields_in_submap().

◆ destroy_furn()

void map::destroy_furn	(	const tripoint &	p,
		bool	silent = `false`
	)

Keeps bashing a square until there is no more furniture.

Definition at line 3751 of file map.cpp.

{
    // Break if it takes more than 25 destructions to remove to prevent infinite loops
    // Example: A bashes to B, B bashes to A leads to A->B->A->...
    int count = 0;
    while( count <= 25 && furn( p ) != f_null && bash( p, 999, silent, true ).success ) {
        count++;
    }
}

References bash(), detail::count(), f_null, furn(), silent, and behavior::success.

Referenced by make_rubble().

◆ destroy_vehicle()

void map::destroy_vehicle ( vehicle * veh )

Definition at line 460 of file map.cpp.

{
    detach_vehicle( veh );
}

References detach_vehicle().

Referenced by MapExtras::burned_ground_parser(), and MapExtras::mx_burned_ground().

◆ detach_vehicle()

std::unique_ptr< vehicle > map::detach_vehicle ( vehicle * veh )

Definition at line 414 of file map.cpp.

{
    if( veh == nullptr ) {
        debugmsg( "map::detach_vehicle was passed nullptr" );
        return std::unique_ptr<vehicle>();
    }
 
    int z = veh->sm_pos.z;
    if( z < -OVERMAP_DEPTH || z > OVERMAP_HEIGHT ) {
        debugmsg( "detach_vehicle got a vehicle outside allowed z-level range!  name=%s, submap:%d,%d,%d",
                  veh->name, veh->sm_pos.x, veh->sm_pos.y, veh->sm_pos.z );
        // Try to fix by moving the vehicle here
        z = veh->sm_pos.z = abs_sub.z;
    }
 
    // Unboard all passengers before detaching
    for( auto const &part : veh->get_avail_parts( VPFLAG_BOARDABLE ) ) {
        player *passenger = part.get_passenger();
        if( passenger ) {
            unboard_vehicle( part, passenger );
        }
    }
    veh->invalidate_towing( true );
    submap *const current_submap = get_submap_at_grid( veh->sm_pos );
    level_cache &ch = get_cache( z );
    for( size_t i = 0; i < current_submap->vehicles.size(); i++ ) {
        if( current_submap->vehicles[i].get() == veh ) {
            ch.vehicle_list.erase( veh );
            ch.zone_vehicles.erase( veh );
            reset_vehicle_cache( );
            std::unique_ptr<vehicle> result = std::move( current_submap->vehicles[i] );
            current_submap->vehicles.erase( current_submap->vehicles.begin() + i );
            if( veh->tracking_on ) {
                overmap_buffer.remove_vehicle( veh );
            }
            dirty_vehicle_list.erase( veh );
            veh->detach();
            veh->refresh_position();
            return result;
        }
    }
    debugmsg( "detach_vehicle can't find it!  name=%s, submap:%d,%d,%d", veh->name, veh->sm_pos.x,
              veh->sm_pos.y, veh->sm_pos.z );
    return std::unique_ptr<vehicle>();
}

References abs_sub, debugmsg, vehicle::detach(), dirty_vehicle_list, vehicle::get_avail_parts(), get_cache(), get_submap_at_grid(), vehicle::invalidate_towing(), avatar_action::move(), vehicle::name, overmap_buffer, OVERMAP_HEIGHT, vehicle::refresh_position(), overmapbuffer::remove_vehicle(), reset_vehicle_cache(), vehicle::sm_pos, vehicle::tracking_on, unboard_vehicle(), level_cache::vehicle_list, submap::vehicles, VPFLAG_BOARDABLE, tripoint::x, tripoint::y, tripoint::z, and level_cache::zone_vehicles.

Referenced by add_vehicle_to_map(), destroy_vehicle(), and editmap::mapgen_veh_destroy().

◆ determine_wall_corner()

int map::determine_wall_corner ( const tripoint & p ) const

private

Definition at line 7990 of file map.cpp.

{
    int test_connect_group = ter( p ).obj().connect_group;
    uint8_t connections = get_known_connections( p, test_connect_group );
    // The bits in connections are SEWN, whereas the characters in LINE_
    // constants are NESW, so we want values in 8 | 2 | 1 | 4 order.
    switch( connections ) {
        case 8 | 2 | 1 | 4:
            return LINE_XXXX;
        case 0 | 2 | 1 | 4:
            return LINE_OXXX;
 
        case 8 | 0 | 1 | 4:
            return LINE_XOXX;
        case 0 | 0 | 1 | 4:
            return LINE_OOXX;
 
        case 8 | 2 | 0 | 4:
            return LINE_XXOX;
        case 0 | 2 | 0 | 4:
            return LINE_OXOX;
        case 8 | 0 | 0 | 4:
            return LINE_XOOX;
        case 0 | 0 | 0 | 4:
            return LINE_OXOX; // LINE_OOOX would be better
 
        case 8 | 2 | 1 | 0:
            return LINE_XXXO;
        case 0 | 2 | 1 | 0:
            return LINE_OXXO;
        case 8 | 0 | 1 | 0:
            return LINE_XOXO;
        case 0 | 0 | 1 | 0:
            return LINE_XOXO; // LINE_OOXO would be better
        case 8 | 2 | 0 | 0:
            return LINE_XXOO;
        case 0 | 2 | 0 | 0:
            return LINE_OXOX; // LINE_OXOO would be better
        case 8 | 0 | 0 | 0:
            return LINE_XOXO; // LINE_XOOO would be better
 
        case 0 | 0 | 0 | 0:
            return ter( p ).obj().symbol(); // technically just a column
 
        default:
            // assert( false );
            // this shall not happen
            return '?';
    }
}

References map_data_common_t::connect_group, anonymous_namespace{overmap_connection.cpp}::connections, get_known_connections(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XOXX, LINE_XXOO, LINE_XXOX, LINE_XXXO, LINE_XXXX, int_id< T >::obj(), map_data_common_t::symbol(), and ter().

Referenced by draw_from_above(), and draw_maptile().

◆ disarm_trap()

void map::disarm_trap ( const tripoint & p )

Perception increases chance of disarming trap Dexterity increases chance of disarming trap Traps increases chance of disarming trap

Definition at line 5336 of file map.cpp.

{
    const trap &tr = tr_at( p );
    if( tr.is_null() ) {
        debugmsg( "Tried to disarm a trap where there was none (%d %d %d)", p.x, p.y, p.z );
        return;
    }
 
    const int tSkillLevel = g->u.get_skill_level( skill_traps );
    const int diff = tr.get_difficulty();
    int roll = rng( tSkillLevel, 4 * tSkillLevel );
 
    // Some traps are not actual traps. Skip the rolls, different message and give the option to grab it right away.
    if( tr.get_avoidance() == 0 && tr.get_difficulty() == 0 ) {
        add_msg( _( "The %s is taken down." ), tr.name() );
        tr.on_disarmed( *this, p );
        return;
    }
 
    ///\EFFECT_PER increases chance of disarming trap
 
    ///\EFFECT_DEX increases chance of disarming trap
 
    ///\EFFECT_TRAPS increases chance of disarming trap
    while( ( rng( 5, 20 ) < g->u.per_cur || rng( 1, 20 ) < g->u.dex_cur ) && roll < 50 ) {
        roll++;
    }
    if( roll >= diff ) {
        add_msg( _( "You disarm the trap!" ) );
        const int morale_buff = tr.get_avoidance() * 0.4 + tr.get_difficulty() + rng( 0, 4 );
        g->u.rem_morale( MORALE_FAILURE );
        g->u.add_morale( MORALE_ACCOMPLISHMENT, morale_buff, 40 );
        tr.on_disarmed( *this, p );
        if( diff > 1.25 * tSkillLevel ) { // failure might have set off trap
            g->u.practice( skill_traps, 1.5 * ( diff - tSkillLevel ) );
        }
    } else if( roll >= diff * .8 ) {
        add_msg( _( "You fail to disarm the trap." ) );
        const int morale_debuff = -rng( 6, 18 );
        g->u.rem_morale( MORALE_ACCOMPLISHMENT );
        g->u.add_morale( MORALE_FAILURE, morale_debuff, -40 );
        if( diff > 1.25 * tSkillLevel ) {
            g->u.practice( skill_traps, 1.5 * ( diff - tSkillLevel ) );
        }
    } else {
        add_msg( m_bad, _( "You fail to disarm the trap, and you set it off!" ) );
        const int morale_debuff = -rng( 12, 24 );
        g->u.rem_morale( MORALE_ACCOMPLISHMENT );
        g->u.add_morale( MORALE_FAILURE, morale_debuff, -40 );
        tr.trigger( p, &g->u );
        if( diff - roll <= 6 ) {
            // Give xp for failing, but not if we failed terribly (in which
            // case the trap may not be disarmable).
            g->u.practice( skill_traps, 2 * diff );
        }
    }
}

References _, add_msg(), debugmsg, g, trap::get_avoidance(), trap::get_difficulty(), trap::is_null(), m_bad, MORALE_ACCOMPLISHMENT, MORALE_FAILURE, trap::name(), trap::on_disarmed(), rng(), skill_traps, tr_at(), trap::trigger(), tripoint::x, tripoint::y, and tripoint::z.

◆ disp_name()

std::string map::disp_name ( const tripoint & p )

Definition at line 1395 of file map.cpp.

{
    return string_format( _( "the %s" ), name( p ) );
}

References _, name(), and string_format().

◆ displace_vehicle()

bool map::displace_vehicle	(	vehicle &	veh,
		const tripoint &	dp
	)

Definition at line 1184 of file map.cpp.

{
    const tripoint src = veh.global_pos3();
 
    tripoint dst = src + dp;
 
    if( !inbounds( src ) ) {
        add_msg( m_debug, "map::displace_vehicle: coordinates out of bounds %d,%d,%d->%d,%d,%d",
                 src.x, src.y, src.z, dst.x, dst.y, dst.z );
        return false;
    }
 
    point src_offset;
    point dst_offset;
    submap *src_submap = get_submap_at( src, src_offset );
    submap *dst_submap = get_submap_at( dst, dst_offset );
    std::set<int> smzs;
 
    // first, let's find our position in current vehicles vector
    size_t our_i = 0;
    bool found = false;
    for( auto &smap : grid ) {
        for( size_t i = 0; i < smap->vehicles.size(); i++ ) {
            if( smap->vehicles[i].get() == &veh ) {
                our_i = i;
                src_submap = smap;
                found = true;
                break;
            }
        }
        if( found ) {
            break;
        }
    }
 
    if( !found ) {
        add_msg( m_debug, "displace_vehicle [%s] failed", veh.name );
        return false;
    }
 
    // move the vehicle
    // don't let it go off grid
    if( !inbounds( dst ) ) {
        veh.stop();
        // Silent debug
        dbg( DL::Error ) << "map:displace_vehicle: Stopping vehicle, displaced dp=" << dp;
        return true;
    }
 
    // Need old coordinates to check for remote control
    const bool remote = veh.remote_controlled( g->u );
 
    // record every passenger and pet inside
    std::vector<rider_data> riders = veh.get_riders();
 
    bool need_update = false;
    bool z_change = false;
    int z_to = 0;
    // Move passengers and pets
    bool complete = false;
    // loop until everyone has moved or for each passenger
    for( size_t i = 0; !complete && i < riders.size(); i++ ) {
        complete = true;
        for( rider_data &r : riders ) {
            if( r.moved ) {
                continue;
            }
            const int prt = r.prt;
 
            Creature *psg = r.psg;
            const tripoint part_pos = veh.global_part_pos3( prt );
            if( psg == nullptr ) {
                debugmsg( "Empty passenger for part #%d at %d,%d,%d player at %d,%d,%d?",
                          prt, part_pos.x, part_pos.y, part_pos.z,
                          g->u.posx(), g->u.posy(), g->u.posz() );
                veh.part( prt ).remove_flag( vehicle_part::passenger_flag );
                r.moved = true;
                continue;
            }
 
            if( psg->pos() != part_pos ) {
                add_msg( m_debug, "Part/passenger position mismatch: part #%d at %d,%d,%d "
                         "passenger at %d,%d,%d", prt, part_pos.x, part_pos.y, part_pos.z,
                         psg->posx(), psg->posy(), psg->posz() );
            }
            const vehicle_part &veh_part = veh.part( prt );
 
            tripoint next_pos = veh_part.precalc[1];
 
            // Place passenger on the new part location
            tripoint psgp( dst + next_pos );
            // someone is in the way so try again
            if( g->critter_at( psgp ) ) {
                complete = false;
                continue;
            }
            if( psg->is_avatar() ) {
                // If passenger is you, we need to update the map
                need_update = true;
                z_change = psgp.z != part_pos.z;
                z_to = psgp.z;
            }
 
            psg->setpos( psgp );
            r.moved = true;
        }
    }
 
    veh.shed_loose_parts();
    smzs = veh.advance_precalc_mounts( dst_offset, src );
    if( src_submap != dst_submap ) {
        veh.set_submap_moved( tripoint( dst.x / SEEX, dst.y / SEEY, dst.z ) );
        auto src_submap_veh_it = src_submap->vehicles.begin() + our_i;
        dst_submap->vehicles.push_back( std::move( *src_submap_veh_it ) );
        src_submap->vehicles.erase( src_submap_veh_it );
        dst_submap->is_uniform = false;
        invalidate_max_populated_zlev( dst.z );
    }
    if( need_update ) {
        g->update_map( g->u );
    }
    add_vehicle_to_cache( &veh );
 
    if( z_change || src.z != dst.z ) {
        if( z_change ) {
            g->vertical_shift( z_to );
            // vertical moves can flush the caches, so make sure we're still in the cache
            add_vehicle_to_cache( &veh );
        }
        update_vehicle_list( dst_submap, dst.z );
        // delete the vehicle from the source z-level vehicle cache set if it is no longer on
        // that z-level
        if( src.z != dst.z ) {
            level_cache &ch2 = get_cache( src.z );
            for( const vehicle *elem : ch2.vehicle_list ) {
                if( elem == &veh ) {
                    ch2.vehicle_list.erase( &veh );
                    ch2.zone_vehicles.erase( &veh );
                    break;
                }
            }
        }
        veh.check_is_heli_landed();
    }
 
    if( remote ) {
        // Has to be after update_map or coordinates won't be valid
        g->setremoteveh( &veh );
    }
 
    //
    //global positions of vehicle loot zones have changed.
    veh.zones_dirty = true;
 
    for( int vsmz : smzs ) {
        on_vehicle_moved( dst.z + vsmz );
    }
    return true;
}

References add_msg(), add_vehicle_to_cache(), vehicle::advance_precalc_mounts(), vehicle::check_is_heli_landed(), dbg, debugmsg, Error, g, get_cache(), vehicle::get_riders(), get_submap_at(), vehicle::global_part_pos3(), vehicle::global_pos3(), grid, inbounds(), invalidate_max_populated_zlev(), Creature::is_avatar(), submap::is_uniform, m_debug, avatar_action::move(), vehicle::name, on_vehicle_moved(), vehicle::part(), vehicle_part::passenger_flag, Creature::pos(), Creature::posx(), Creature::posy(), Creature::posz(), vehicle_part::precalc, vehicle::remote_controlled(), vehicle_part::remove_flag(), SEEX, SEEY, vehicle::set_submap_moved(), Creature::setpos(), vehicle::shed_loose_parts(), vehicle::stop(), update_vehicle_list(), level_cache::vehicle_list, submap::vehicles, tripoint::x, tripoint::y, tripoint::z, level_cache::zone_vehicles, and vehicle::zones_dirty.

Referenced by game::grabbed_veh_move(), and move_vehicle().

◆ displace_water()

bool map::displace_water ( const tripoint & dp )

Definition at line 1344 of file map.cpp.

{
    // Check for shallow water
    if( has_flag( "SWIMMABLE", p ) && !has_flag( TFLAG_DEEP_WATER, p ) ) {
        int dis_places = 0;
        int sel_place = 0;
        for( int pass = 0; pass < 2; pass++ ) {
            // we do 2 passes.
            // first, count how many non-water places around
            // then choose one within count and fill it with water on second pass
            if( pass != 0 ) {
                sel_place = rng( 0, dis_places - 1 );
                dis_places = 0;
            }
            for( const tripoint &temp : points_in_radius( p, 1 ) ) {
                if( temp != p
                    || impassable_ter_furn( temp )
                    || has_flag( TFLAG_DEEP_WATER, temp ) ) {
                    continue;
                }
                ter_id ter0 = ter( temp );
                if( ter0 == t_water_sh ||
                    ter0 == t_water_dp || ter0 == t_water_moving_sh || ter0 == t_water_moving_dp ) {
                    continue;
                }
                if( pass != 0 && dis_places == sel_place ) {
                    ter_set( temp, t_water_sh );
                    ter_set( temp, t_dirt );
                    return true;
                }
 
                dis_places++;
            }
        }
    }
    return false;
}

References has_flag(), impassable_ter_furn(), points_in_radius(), rng(), t_dirt, t_water_dp, t_water_moving_dp, t_water_moving_sh, t_water_sh, ter(), ter_set(), and TFLAG_DEEP_WATER.

Referenced by move_vehicle().

◆ do_vehicle_caching()

void map::do_vehicle_caching ( int z )

Definition at line 8345 of file map.cpp.

{
    level_cache &ch = get_cache( z );
    for( vehicle *v : ch.vehicle_list ) {
        for( const vpart_reference &vp : v->get_all_parts() ) {
            const tripoint &part_pos = v->global_part_pos3( vp.part() );
            if( !inbounds( part_pos.xy() ) || vp.part().removed ) {
                continue;
            }
            vehicle_caching_internal( get_cache( part_pos.z ), vp, v );
            if( part_pos.z < OVERMAP_HEIGHT ) {
                vehicle_caching_internal_above( get_cache( part_pos.z + 1 ), vp, v );
            }
        }
    }
}

References vehicle::get_all_parts(), get_cache(), vehicle::global_part_pos3(), inbounds(), OVERMAP_HEIGHT, vehicle_caching_internal(), vehicle_caching_internal_above(), level_cache::vehicle_list, tripoint::xy(), and tripoint::z.

Referenced by build_map_cache().

◆ dont_draw_lower_floor()

bool map::dont_draw_lower_floor ( const tripoint & p )

Definition at line 5999 of file map.cpp.

{
    return !zlevels || p.z <= -OVERMAP_DEPTH ||
           !( has_flag( TFLAG_NO_FLOOR, p ) || has_flag( TFLAG_Z_TRANSPARENT, p ) );
}

References has_flag(), OVERMAP_DEPTH, TFLAG_NO_FLOOR, TFLAG_Z_TRANSPARENT, tripoint::z, and zlevels.

◆ draw()

void map::draw	(	const catacurses::window &	w,
		const tripoint &	center
	)

Draw a visible part of the map into w.

This method uses g->u.posx()/posy() for visibility calculations, so it can not be used for anything but the player's viewport. Likewise, only g->m and maps with equivalent coordinates can be used, as other maps would have coordinate systems incompatible with g->u.posx()

Parameters

w	Window we are drawing in
center	The coordinate of the center of the viewport, this can be different from the player coordinate.

Definition at line 5840 of file map.cpp.

{
    // We only need to draw anything if we're not in tiles mode.
    if( is_draw_tiles_mode() ) {
        return;
    }
 
    g->reset_light_level();
 
    update_visibility_cache( center.z );
    const visibility_variables &cache = get_visibility_variables_cache();
 
    const auto &visibility_cache = get_cache_ref( center.z ).visibility_cache;
 
    int wnd_h = getmaxy( w );
    int wnd_w = getmaxx( w );
    const tripoint offs = center - tripoint( wnd_w / 2, wnd_h / 2, 0 );
 
    // Map memory should be at least the size of the view range
    // so that new tiles can be memorized, and at least the size of the terminal
    // since displayed area may be bigger than view range.
    const point min_mm_reg = point(
                                 std::min( 0, offs.x ),
                                 std::min( 0, offs.y )
                             );
    const point max_mm_reg = point(
                                 std::max( MAPSIZE_X, offs.x + wnd_w ),
                                 std::max( MAPSIZE_Y, offs.y + wnd_h )
                             );
    g->u.prepare_map_memory_region(
        g->m.getabs( tripoint( min_mm_reg, center.z ) ),
        g->m.getabs( tripoint( max_mm_reg, center.z ) )
    );
 
    const auto draw_background = [&]( const tripoint & p ) {
        int sym = ' ';
        nc_color col = c_black;
        if( has_memory_at( p ) ) {
            sym = get_memory_at( p );
            col = c_brown;
        }
        wputch( w, col, sym );
    };
 
    const auto draw_vision_effect = [&]( const visibility_type vis ) -> bool {
        int sym = '#';
        nc_color col;
        switch( vis )
        {
            case VIS_LIT:
                // can only tell that this square is bright
                col = c_light_gray;
                break;
            case VIS_BOOMER:
                col = c_pink;
                break;
            case VIS_BOOMER_DARK:
                col = c_magenta;
                break;
            default:
                return false;
        }
        wputch( w, col, sym );
        return true;
    };
 
    drawsq_params params = drawsq_params().memorize( true );
    for( int wy = 0; wy < wnd_h; wy++ ) {
        for( int wx = 0; wx < wnd_w; wx++ ) {
            wmove( w, point( wx, wy ) );
            const tripoint p = offs + tripoint( wx, wy, 0 );
            if( !inbounds( p ) ) {
                draw_background( p );
                continue;
            }
 
            const lit_level lighting = visibility_cache[p.x][p.y];
            const visibility_type vis = get_visibility( lighting, cache );
 
            if( draw_vision_effect( vis ) ) {
                continue;
            }
 
            if( vis == VIS_HIDDEN || vis == VIS_DARK ) {
                draw_background( p );
                continue;
            }
 
            const maptile curr_maptile = maptile_at_internal( p );
            params
            .low_light( lighting == lit_level::LOW )
            .bright_light( lighting == lit_level::BRIGHT );
            if( draw_maptile( w, p, curr_maptile, params ) ) {
                continue;
            }
            const maptile tile_below = maptile_at_internal( p - tripoint_above );
            draw_from_above( w, tripoint( p.xy(), p.z - 1 ), tile_below, params );
        }
    }
 
    // Memorize off-screen tiles
    half_open_rectangle<point> display( offs.xy(), offs.xy() + point( wnd_w, wnd_h ) );
    drawsq_params mm_params = drawsq_params().memorize( true ).output( false );
    for( int y = 0; y < MAPSIZE_Y; y++ ) {
        for( int x = 0; x < MAPSIZE_X; x++ ) {
            const tripoint p( x, y, center.z );
            if( display.contains( p.xy() ) ) {
                // Have been memorized during display loop
                continue;
            }
 
            const lit_level lighting = visibility_cache[p.x][p.y];
            const visibility_type vis = get_visibility( lighting, cache );
 
            if( vis != VIS_CLEAR ) {
                continue;
            }
 
            const maptile curr_maptile = maptile_at_internal( p );
            mm_params
            .low_light( lighting == lit_level::LOW )
            .bright_light( lighting == lit_level::BRIGHT );
 
            draw_maptile( w, p, curr_maptile, mm_params );
        }
    }
}

References BRIGHT, drawsq_params::bright_light(), c_black, c_brown, c_light_gray, c_magenta, c_pink, center, overmap_ui::display(), draw_from_above(), draw_maptile(), g, get_cache_ref(), get_memory_at(), get_visibility(), get_visibility_variables_cache(), catacurses::getmaxx(), catacurses::getmaxy(), has_memory_at(), inbounds(), is_draw_tiles_mode(), LOW, drawsq_params::low_light(), MAPSIZE_X, MAPSIZE_Y, maptile_at_internal(), drawsq_params::memorize(), drawsq_params::output(), tripoint_above, update_visibility_cache(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, level_cache::visibility_cache, catacurses::wmove(), wputch(), tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by advanced_inventory::draw_minimap(), and game::draw_ter().

◆ draw_anthill()

void map::draw_anthill ( mapgendata & dat )

protected

Definition at line 4864 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( terrain_type == "anthill" || terrain_type == "acid_anthill" ) {
        for( int i = 0; i < SEEX * 2; i++ ) {
            for( int j = 0; j < SEEY * 2; j++ ) {
                if( i < 8 || j < 8 || i > SEEX * 2 - 9 || j > SEEY * 2 - 9 ) {
                    ter_set( point( i, j ), dat.groundcover() );
                } else if( ( i == 11 || i == 12 ) && ( j == 11 || j == 12 ) ) {
                    ter_set( point( i, j ), t_slope_down );
                } else {
                    ter_set( point( i, j ), t_dirtmound );
                }
            }
        }
    }
}

References mapgendata::groundcover(), SEEX, SEEY, t_dirtmound, t_slope_down, ter_set(), and mapgendata::terrain_type().

Referenced by draw_map().

◆ draw_circle_furn()

void map::draw_circle_furn	(	const furn_id &	type,
		point	p,
		int	rad
	)

Definition at line 8596 of file map.cpp.

{
    draw_circle( [this, type]( point  q ) {
        this->furn_set( q, type );
    }, p, rad );
}

References draw_circle(), furn_set(), rad, and type.

Referenced by circle_furn().

◆ draw_circle_ter() [1/2]

void map::draw_circle_ter	(	const ter_id &	type,
		const rl_vec2d &	p,
		double	rad
	)

Definition at line 8582 of file map.cpp.

{
    draw_circle( [this, type]( point  q ) {
        this->ter_set( q, type );
    }, p, rad );
}

References draw_circle(), rad, ter_set(), and type.

Referenced by circle().

◆ draw_circle_ter() [2/2]

void map::draw_circle_ter	(	const ter_id &	type,
		point	p,
		int	rad
	)

Definition at line 8589 of file map.cpp.

{
    draw_circle( [this, type]( point  q ) {
        this->ter_set( q, type );
    }, p, rad );
}

References draw_circle(), rad, ter_set(), and type.

◆ draw_connections()

void map::draw_connections ( mapgendata & dat )

protected

Definition at line 5074 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( is_ot_match( "subway", terrain_type,
                     ot_match_type::type ) ) { // FUUUUU it's IF ELIF ELIF ELIF's mini-me =[
        if( is_ot_match( "sewer", dat.north(), ot_match_type::type ) &&
            !connects_to( terrain_type, 0 ) ) {
            if( connects_to( dat.north(), 2 ) ) {
                for( int i = SEEX - 2; i < SEEX + 2; i++ ) {
                    for( int j = 0; j < SEEY; j++ ) {
                        ter_set( point( i, j ), t_sewage );
                    }
                }
            } else {
                for( int j = 0; j < 3; j++ ) {
                    ter_set( point( SEEX, j ), t_rock_floor );
                    ter_set( point( SEEX - 1, j ), t_rock_floor );
                }
                ter_set( point( SEEX, 3 ), t_door_metal_c );
                ter_set( point( SEEX - 1, 3 ), t_door_metal_c );
            }
        }
        if( is_ot_match( "sewer", dat.east(), ot_match_type::type ) &&
            !connects_to( terrain_type, 1 ) ) {
            if( connects_to( dat.east(), 3 ) ) {
                for( int i = SEEX; i < SEEX * 2; i++ ) {
                    for( int j = SEEY - 2; j < SEEY + 2; j++ ) {
                        ter_set( point( i, j ), t_sewage );
                    }
                }
            } else {
                for( int i = SEEX * 2 - 3; i < SEEX * 2; i++ ) {
                    ter_set( point( i, SEEY ), t_rock_floor );
                    ter_set( point( i, SEEY - 1 ), t_rock_floor );
                }
                ter_set( point( SEEX * 2 - 4, SEEY ), t_door_metal_c );
                ter_set( point( SEEX * 2 - 4, SEEY - 1 ), t_door_metal_c );
            }
        }
        if( is_ot_match( "sewer", dat.south(), ot_match_type::type ) &&
            !connects_to( terrain_type, 2 ) ) {
            if( connects_to( dat.south(), 0 ) ) {
                for( int i = SEEX - 2; i < SEEX + 2; i++ ) {
                    for( int j = SEEY; j < SEEY * 2; j++ ) {
                        ter_set( point( i, j ), t_sewage );
                    }
                }
            } else {
                for( int j = SEEY * 2 - 3; j < SEEY * 2; j++ ) {
                    ter_set( point( SEEX, j ), t_rock_floor );
                    ter_set( point( SEEX - 1, j ), t_rock_floor );
                }
                ter_set( point( SEEX, SEEY * 2 - 4 ), t_door_metal_c );
                ter_set( point( SEEX - 1, SEEY * 2 - 4 ), t_door_metal_c );
            }
        }
        if( is_ot_match( "sewer", dat.west(), ot_match_type::type ) &&
            !connects_to( terrain_type, 3 ) ) {
            if( connects_to( dat.west(), 1 ) ) {
                for( int i = 0; i < SEEX; i++ ) {
                    for( int j = SEEY - 2; j < SEEY + 2; j++ ) {
                        ter_set( point( i, j ), t_sewage );
                    }
                }
            } else {
                for( int i = 0; i < 3; i++ ) {
                    ter_set( point( i, SEEY ), t_rock_floor );
                    ter_set( point( i, SEEY - 1 ), t_rock_floor );
                }
                ter_set( point( 3, SEEY ), t_door_metal_c );
                ter_set( point( 3, SEEY - 1 ), t_door_metal_c );
            }
        }
    } else if( is_ot_match( "sewer", terrain_type, ot_match_type::type ) ) {
        if( dat.above() == "road_nesw_manhole" ) {
            ter_set( point( rng( SEEX - 2, SEEX + 1 ), rng( SEEY - 2, SEEY + 1 ) ), t_ladder_up );
        }
        if( is_ot_match( "subway", dat.north(), ot_match_type::type ) &&
            !connects_to( terrain_type, 0 ) ) {
            for( int j = 0; j < SEEY - 3; j++ ) {
                ter_set( point( SEEX, j ), t_rock_floor );
                ter_set( point( SEEX - 1, j ), t_rock_floor );
            }
            ter_set( point( SEEX, SEEY - 3 ), t_door_metal_c );
            ter_set( point( SEEX - 1, SEEY - 3 ), t_door_metal_c );
        }
        if( is_ot_match( "subway", dat.east(), ot_match_type::type ) &&
            !connects_to( terrain_type, 1 ) ) {
            for( int i = SEEX + 3; i < SEEX * 2; i++ ) {
                ter_set( point( i, SEEY ), t_rock_floor );
                ter_set( point( i, SEEY - 1 ), t_rock_floor );
            }
            ter_set( point( SEEX + 2, SEEY ), t_door_metal_c );
            ter_set( point( SEEX + 2, SEEY - 1 ), t_door_metal_c );
        }
        if( is_ot_match( "subway", dat.south(), ot_match_type::type ) &&
            !connects_to( terrain_type, 2 ) ) {
            for( int j = SEEY + 3; j < SEEY * 2; j++ ) {
                ter_set( point( SEEX, j ), t_rock_floor );
                ter_set( point( SEEX - 1, j ), t_rock_floor );
            }
            ter_set( point( SEEX, SEEY + 2 ), t_door_metal_c );
            ter_set( point( SEEX - 1, SEEY + 2 ), t_door_metal_c );
        }
        if( is_ot_match( "subway", dat.west(), ot_match_type::type ) &&
            !connects_to( terrain_type, 3 ) ) {
            for( int i = 0; i < SEEX - 3; i++ ) {
                ter_set( point( i, SEEY ), t_rock_floor );
                ter_set( point( i, SEEY - 1 ), t_rock_floor );
            }
            ter_set( point( SEEX - 3, SEEY ), t_door_metal_c );
            ter_set( point( SEEX - 3, SEEY - 1 ), t_door_metal_c );
        }
    } else if( is_ot_match( "ants", terrain_type, ot_match_type::type ) ) {
        if( dat.above() == "anthill" ) {
            if( const auto p = random_point( *this, [this]( const tripoint & n ) {
            return ter( n ) == t_rock_floor;
            } ) ) {
                ter_set( *p, t_slope_up );
            }
        }
    }
 
    // finally, any terrain with SIDEWALKS should contribute sidewalks to neighboring diagonal roads
    if( terrain_type->has_flag( has_sidewalk ) ) {
        for( int dir = 4; dir < 8; dir++ ) { // NE SE SW NW
            bool n_roads_nesw[4] = {};
            int n_num_dirs = terrain_type_to_nesw_array( oter_id( dat.t_nesw[dir] ), n_roads_nesw );
            // only handle diagonal neighbors
            if( n_num_dirs == 2 &&
                n_roads_nesw[( ( dir - 4 ) + 3 ) % 4] &&
                n_roads_nesw[( ( dir - 4 ) + 2 ) % 4] ) {
                // make drawing simpler by rotating the map back and forth
                rotate( 4 - ( dir - 4 ) );
                // draw a small triangle of sidewalk in the northeast corner
                for( int y = 0; y < 4; y++ ) {
                    for( int x = SEEX * 2 - 4; x < SEEX * 2; x++ ) {
                        if( x - y > SEEX * 2 - 4 ) {
                            // TODO: more discriminating conditions
                            if( ter( point( x, y ) ) == t_grass || ter( point( x, y ) ) == t_dirt ||
                                ter( point( x, y ) ) == t_shrub ) {
                                ter_set( point( x, y ), t_sidewalk );
                            }
                        }
                    }
                }
                rotate( ( dir - 4 ) );
            }
        }
    }
 
    resolve_regional_terrain_and_furniture( dat );
}

References mapgendata::above(), connects_to(), mapgendata::east(), oter_t::has_flag(), has_sidewalk, is_ot_match(), mapgendata::north(), oter_id, random_point(), resolve_regional_terrain_and_furniture(), rng(), rotate(), SEEX, SEEY, mapgendata::south(), t_dirt, t_door_metal_c, t_grass, t_ladder_up, mapgendata::t_nesw, t_rock_floor, t_sewage, t_shrub, t_sidewalk, t_slope_up, ter(), ter_set(), mapgendata::terrain_type(), terrain_type_to_nesw_array(), type, and mapgendata::west().

Referenced by draw_map().

◆ draw_fill_background() [1/3]

void map::draw_fill_background ( const ter_id & type )

Definition at line 8511 of file map.cpp.

{
    // Need to explicitly set caches dirty - set_ter would do it before
    set_transparency_cache_dirty( abs_sub.z );
    set_seen_cache_dirty( abs_sub.z );
    set_outside_cache_dirty( abs_sub.z );
    set_pathfinding_cache_dirty( abs_sub.z );
 
    // Fill each submap rather than each tile
    for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
        for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
            auto sm = get_submap_at_grid( {gridx, gridy} );
            sm->is_uniform = true;
            sm->set_all_ter( type );
        }
    }
}

References abs_sub, get_submap_at_grid(), my_MAPSIZE, set_outside_cache_dirty(), set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_transparency_cache_dirty(), coords::sm, type, and tripoint::z.

Referenced by fill_background(), mapgendata::fill_groundcover(), mapgen_function_json::generate(), and mapgen_forest().

◆ draw_fill_background() [2/3]

void map::draw_fill_background ( const weighted_int_list< ter_id > & f )

Definition at line 8533 of file map.cpp.

{
    draw_square_ter( f, point_zero, point( SEEX * my_MAPSIZE - 1, SEEY * my_MAPSIZE - 1 ) );
}

References draw_square_ter(), my_MAPSIZE, point_zero, SEEX, and SEEY.

◆ draw_fill_background() [3/3]

void map::draw_fill_background ( ter_id(*)() f )

Definition at line 8529 of file map.cpp.

{
    draw_square_ter( f, point_zero, point( SEEX * my_MAPSIZE - 1, SEEY * my_MAPSIZE - 1 ) );
}

References draw_square_ter(), my_MAPSIZE, point_zero, SEEX, and SEEY.

◆ draw_from_above()

void map::draw_from_above	(	const catacurses::window &	w,
		const tripoint &	p,
		const maptile &	tile,
		const drawsq_params &	params
	)		const

private

Draws the tile as seen from above.

Definition at line 6196 of file map.cpp.

{
    static const int AUTO_WALL_PLACEHOLDER = 2; // this should never appear as a real symbol!
 
    nc_color tercol = c_dark_gray;
    int sym = ' ';
 
    const ter_t &curr_ter = curr_tile.get_ter_t();
    const furn_t &curr_furn = curr_tile.get_furn_t();
    int part_below;
    const vehicle *veh;
    if( curr_furn.has_flag( TFLAG_SEEN_FROM_ABOVE ) ) {
        sym = curr_furn.symbol();
        tercol = curr_furn.color();
    } else if( curr_furn.movecost < 0 ) {
        sym = '.';
        tercol = curr_furn.color();
    } else if( ( veh = veh_at_internal( p, part_below ) ) != nullptr ) {
        const int roof = veh->roof_at_part( part_below );
        const int displayed_part = roof >= 0 ? roof : part_below;
        sym = special_symbol( veh->face.dir_symbol( veh->part_sym( displayed_part, true ) ) );
        tercol = ( roof >= 0 ||
                   vpart_position( const_cast<vehicle &>( *veh ),
                                   part_below ).obstacle_at_part() ) ? c_light_gray : c_light_gray_cyan;
    } else if( curr_ter.has_flag( TFLAG_SEEN_FROM_ABOVE ) ) {
        if( curr_ter.has_flag( TFLAG_AUTO_WALL_SYMBOL ) ) {
            sym = AUTO_WALL_PLACEHOLDER;
        } else if( curr_ter.has_flag( TFLAG_RAMP ) ) {
            sym = '>';
        } else {
            sym = curr_ter.symbol();
        }
        tercol = curr_ter.color();
    } else if( curr_ter.movecost == 0 ) {
        sym = '.';
        tercol = curr_ter.color();
    } else if( !curr_ter.has_flag( TFLAG_NO_FLOOR ) ) {
        sym = '.';
        if( curr_ter.color() != c_cyan ) {
            // Need a special case here, it doesn't cyanize well
            tercol = cyan_background( curr_ter.color() );
        } else {
            tercol = c_black_cyan;
        }
    } else {
        sym = curr_ter.symbol();
        tercol = curr_ter.color();
    }
 
    if( sym == AUTO_WALL_PLACEHOLDER ) {
        sym = determine_wall_corner( p );
    }
 
    const auto u_vision = g->u.get_vision_modes();
    if( u_vision[BOOMERED] ) {
        tercol = c_magenta;
    } else if( u_vision[NV_GOGGLES] ) {
        tercol = params.bright_light() ? c_white : c_light_green;
    } else if( params.low_light() ) {
        tercol = c_dark_gray;
    } else if( u_vision[DARKNESS] ) {
        tercol = c_dark_gray;
    }
 
    if( params.highlight() ) {
        tercol = invert_color( tercol );
    }
 
    if( params.output() ) {
        wputch( w, tercol, sym );
    }
}

References BOOMERED, drawsq_params::bright_light(), c_black_cyan, c_cyan, c_dark_gray, c_light_gray, c_light_gray_cyan, c_light_green, c_magenta, c_white, map_data_common_t::color(), cyan_background(), DARKNESS, determine_wall_corner(), tileray::dir_symbol(), vehicle::face, g, maptile::get_furn_t(), maptile::get_ter_t(), map_data_common_t::has_flag(), drawsq_params::highlight(), invert_color(), drawsq_params::low_light(), map_data_common_t::movecost, NV_GOGGLES, vpart_position::obstacle_at_part(), drawsq_params::output(), vehicle::part_sym(), vehicle::roof_at_part(), special_symbol(), map_data_common_t::symbol(), TFLAG_AUTO_WALL_SYMBOL, TFLAG_NO_FLOOR, TFLAG_RAMP, TFLAG_SEEN_FROM_ABOVE, veh_at_internal(), and wputch().

Referenced by draw(), and drawsq().

◆ draw_lab()

void map::draw_lab ( mapgendata & dat )

protected

Definition at line 3553 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    // To distinguish between types of labs
    bool ice_lab = true;
    bool central_lab = false;
    bool tower_lab = false;
 
    point p2;
 
    int lw = 0;
    int rw = 0;
    int tw = 0;
    int bw = 0;
 
    if( terrain_type == "lab" || terrain_type == "lab_stairs" || terrain_type == "lab_core" ||
        terrain_type == "ants_lab" || terrain_type == "ants_lab_stairs" ||
        terrain_type == "ice_lab" || terrain_type == "ice_lab_stairs" ||
        terrain_type == "ice_lab_core" ||
        terrain_type == "central_lab" || terrain_type == "central_lab_stairs" ||
        terrain_type == "central_lab_core" ||
        terrain_type == "tower_lab" || terrain_type == "tower_lab_stairs" ) {
 
        ice_lab = is_ot_match( "ice_lab", terrain_type, ot_match_type::prefix );
        central_lab = is_ot_match( "central_lab", terrain_type, ot_match_type::prefix );
        tower_lab = is_ot_match( "tower_lab", terrain_type, ot_match_type::prefix );
 
        if( ice_lab ) {
            int temperature = -20 + 30 * ( dat.zlevel() );
            set_temperature( p2, temperature );
            set_temperature( p2 + point( SEEX, 0 ), temperature );
            set_temperature( p2 + point( 0, SEEY ), temperature );
            set_temperature( p2 + point( SEEX, SEEY ), temperature );
        }
 
        // Check for adjacent sewers; used below
        tw = 0;
        rw = 0;
        bw = 0;
        lw = 0;
        if( is_ot_match( "sewer", dat.north(), ot_match_type::type ) && connects_to( dat.north(), 2 ) ) {
            tw = SOUTH_EDGE + 1;
        }
        if( is_ot_match( "sewer", dat.east(), ot_match_type::type ) && connects_to( dat.east(), 3 ) ) {
            rw = EAST_EDGE + 1;
        }
        if( is_ot_match( "sewer", dat.south(), ot_match_type::type ) && connects_to( dat.south(), 0 ) ) {
            bw = SOUTH_EDGE + 1;
        }
        if( is_ot_match( "sewer", dat.west(), ot_match_type::type ) && connects_to( dat.west(), 1 ) ) {
            lw = EAST_EDGE + 1;
        }
        if( dat.zlevel() == 0 ) { // We're on ground level
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    if( i <= 1 || i >= SEEX * 2 - 2 ||
                        ( j > 1 && j < SEEY * 2 - 2 && ( i == SEEX - 2 || i == SEEX + 1 ) ) ) {
                        ter_set( point( i, j ), t_concrete_wall );
                    } else if( j <= 1 || j >= SEEY * 2 - 2 ) {
                        ter_set( point( i, j ), t_concrete_wall );
                    } else {
                        ter_set( point( i, j ), t_floor );
                    }
                }
            }
            ter_set( point( SEEX - 1, 0 ), t_door_metal_locked );
            ter_set( point( SEEX - 1, 1 ), t_floor );
            ter_set( point( SEEX, 0 ), t_door_metal_locked );
            ter_set( point( SEEX, 1 ), t_floor );
            ter_set( point( SEEX - 2 + rng( 0, 1 ) * 3, 0 ), t_card_science );
            ter_set( point( SEEX - 2, SEEY ), t_door_metal_c );
            ter_set( point( SEEX + 1, SEEY ), t_door_metal_c );
            ter_set( point( SEEX - 2, SEEY - 1 ), t_door_metal_c );
            ter_set( point( SEEX + 1, SEEY - 1 ), t_door_metal_c );
            ter_set( point( SEEX - 1, SEEY * 2 - 3 ), t_stairs_down );
            ter_set( point( SEEX, SEEY * 2 - 3 ), t_stairs_down );
            science_room( this, point( 2, 2 ), point( SEEX - 3, SEEY * 2 - 3 ), dat.zlevel(), 1 );
            science_room( this, point( SEEX + 2, 2 ), point( SEEX * 2 - 3, SEEY * 2 - 3 ), dat.zlevel(), 3 );
 
            place_spawns( GROUP_TURRET, 1, point( SEEX, 5 ), point( SEEX, 5 ), 1, true );
 
            if( is_ot_match( "road", dat.east(), ot_match_type::type ) ) {
                rotate( 1 );
            } else if( is_ot_match( "road", dat.south(), ot_match_type::type ) ) {
                rotate( 2 );
            } else if( is_ot_match( "road", dat.west(), ot_match_type::type ) ) {
                rotate( 3 );
            }
        } else if( tw != 0 || rw != 0 || lw != 0 || bw != 0 ) { // Sewers!
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    ter_set( point( i, j ), t_thconc_floor );
                    if( ( ( i < lw || i > EAST_EDGE - rw ) && j > SEEY - 3 && j < SEEY + 2 ) ||
                        ( ( j < tw || j > SOUTH_EDGE - bw ) && i > SEEX - 3 && i < SEEX + 2 ) ) {
                        ter_set( point( i, j ), t_sewage );
                    }
                    if( ( i == 0 && is_ot_match( "lab", dat.east(), ot_match_type::contains ) ) || i == EAST_EDGE ) {
                        if( ter( point( i, j ) ) == t_sewage ) {
                            ter_set( point( i, j ), t_bars );
                        } else if( j == SEEY - 1 || j == SEEY ) {
                            ter_set( point( i, j ), t_door_metal_c );
                        } else {
                            ter_set( point( i, j ), t_concrete_wall );
                        }
                    } else if( ( j == 0 && is_ot_match( "lab", dat.north(), ot_match_type::contains ) ) ||
                               j == SOUTH_EDGE ) {
                        if( ter( point( i, j ) ) == t_sewage ) {
                            ter_set( point( i, j ), t_bars );
                        } else if( i == SEEX - 1 || i == SEEX ) {
                            ter_set( point( i, j ), t_door_metal_c );
                        } else {
                            ter_set( point( i, j ), t_concrete_wall );
                        }
                    }
                }
            }
        } else { // We're below ground, and no sewers
            // Set up the boundaries of walls (connect to adjacent lab squares)
            tw = is_ot_match( "lab", dat.north(), ot_match_type::contains ) ? 0 : 2;
            rw = is_ot_match( "lab", dat.east(), ot_match_type::contains ) ? 1 : 2;
            bw = is_ot_match( "lab", dat.south(), ot_match_type::contains ) ? 1 : 2;
            lw = is_ot_match( "lab", dat.west(), ot_match_type::contains ) ? 0 : 2;
 
            int boarders = 0;
            if( tw == 0 ) {
                boarders++;
            }
            if( rw == 1 ) {
                boarders++;
            }
            if( bw == 1 ) {
                boarders++;
            }
            if( lw == 0 ) {
                boarders++;
            }
 
            const auto maybe_insert_stairs = [this]( const oter_id & terrain,  const ter_id & t_stair_type ) {
                if( is_ot_match( "stairs", terrain, ot_match_type::contains ) ) {
                    const auto predicate = [this]( const tripoint & p ) {
                        return ter( p ) == t_thconc_floor && furn( p ) == f_null && tr_at( p ).is_null();
                    };
                    const auto range = points_in_rectangle( { 0, 0, abs_sub.z }, { SEEX * 2 - 2, SEEY * 2 - 2, abs_sub.z } );
 
                    if( const auto p = random_point( range, predicate ) ) {
                        ter_set( *p, t_stair_type );
                    }
                }
            };
 
            //A lab area with only one entrance
            if( boarders == 1 ) {
                // If you remove the usage of "lab_1side" here, remove it from mapgen_factory::get_usages above as well.
                if( oter_mapgen.generate( dat, "lab_1side" ) ) {
                    if( tw == 2 ) {
                        rotate( 2 );
                    }
                    if( rw == 2 ) {
                        rotate( 1 );
                    }
                    if( lw == 2 ) {
                        rotate( 3 );
                    }
                } else {
                    debugmsg( "Error: Tried to generate 1-sided lab but no lab_1side json exists." );
                }
                maybe_insert_stairs( dat.above(), t_stairs_up );
                maybe_insert_stairs( terrain_type, t_stairs_down );
            } else {
                const int hardcoded_4side_map_weight = 1500; // weight of all hardcoded maps.
                // If you remove the usage of "lab_4side" here, remove it from mapgen_factory::get_usages above as well.
                if( oter_mapgen.generate( dat, "lab_4side", hardcoded_4side_map_weight ) ) {
                    // If the map template hasn't handled borders, handle them in code.
                    // Rotated maps cannot handle borders and have to be caught in code.
                    // We determine if a border isn't handled by checking the east-facing
                    // border space where the door normally is -- it should be a wall or door.
                    tripoint east_border( 23, 11, abs_sub.z );
                    if( !has_flag_ter( "WALL", east_border ) &&
                        !has_flag_ter( "DOOR", east_border ) ) {
                        // TODO: create a ter_reset function that does ter_set,
                        // furn_set, and i_clear?
                        ter_id lw_type = tower_lab ? t_reinforced_glass : t_concrete_wall;
                        ter_id tw_type = tower_lab ? t_reinforced_glass : t_concrete_wall;
                        ter_id rw_type = tower_lab && rw == 2 ? t_reinforced_glass :
                                         t_concrete_wall;
                        ter_id bw_type = tower_lab && bw == 2 ? t_reinforced_glass :
                                         t_concrete_wall;
                        for( int i = 0; i < SEEX * 2; i++ ) {
                            ter_set( point( 23, i ), rw_type );
                            furn_set( point( 23, i ), f_null );
                            i_clear( tripoint( 23, i, get_abs_sub().z ) );
 
                            ter_set( point( i, 23 ), bw_type );
                            furn_set( point( i, 23 ), f_null );
                            i_clear( tripoint( i, 23, get_abs_sub().z ) );
 
                            if( lw == 2 ) {
                                ter_set( point( 0, i ), lw_type );
                                furn_set( point( 0, i ), f_null );
                                i_clear( tripoint( 0, i, get_abs_sub().z ) );
                            }
                            if( tw == 2 ) {
                                ter_set( point( i, 0 ), tw_type );
                                furn_set( point( i, 0 ), f_null );
                                i_clear( tripoint( i, 0, get_abs_sub().z ) );
                            }
                        }
                        if( rw != 2 ) {
                            ter_set( point( 23, 11 ), t_door_metal_c );
                            ter_set( point( 23, 12 ), t_door_metal_c );
                        }
                        if( bw != 2 ) {
                            ter_set( point( 11, 23 ), t_door_metal_c );
                            ter_set( point( 12, 23 ), t_door_metal_c );
                        }
                    }
 
                    maybe_insert_stairs( dat.above(), t_stairs_up );
                    maybe_insert_stairs( terrain_type, t_stairs_down );
                } else { // then no json maps for lab_4side were found
                    switch( rng( 1, 3 ) ) {
                        case 1:
                            // Cross shaped
                            for( int i = 0; i < SEEX * 2; i++ ) {
                                for( int j = 0; j < SEEY * 2; j++ ) {
                                    if( ( i < lw || i > EAST_EDGE - rw ) ||
                                        ( ( j < SEEY - 1 || j > SEEY ) &&
                                          ( i == SEEX - 2 || i == SEEX + 1 ) ) ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else if( ( j < tw || j > SOUTH_EDGE - bw ) ||
                                               ( ( i < SEEX - 1 || i > SEEX ) &&
                                                 ( j == SEEY - 2 || j == SEEY + 1 ) ) ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else {
                                        ter_set( point( i, j ), t_thconc_floor );
                                    }
                                }
                            }
                            if( is_ot_match( "stairs", dat.above(), ot_match_type::contains ) ) {
                                ter_set( point( rng( SEEX - 1, SEEX ), rng( SEEY - 1, SEEY ) ),
                                         t_stairs_up );
                            }
                            // Top left
                            if( one_in( 2 ) ) {
                                ter_set( point( SEEX - 2, int( SEEY / 2 ) ), t_door_glass_frosted_c );
                                science_room( this, point( lw, tw ), point( SEEX - 3, SEEY - 3 ), dat.zlevel(), 1 );
                            } else {
                                ter_set( point( SEEX / 2, SEEY - 2 ), t_door_glass_frosted_c );
                                science_room( this, point( lw, tw ), point( SEEX - 3, SEEY - 3 ), dat.zlevel(), 2 );
                            }
                            // Top right
                            if( one_in( 2 ) ) {
                                ter_set( point( SEEX + 1, int( SEEY / 2 ) ), t_door_glass_frosted_c );
                                science_room( this, point( SEEX + 2, tw ), point( EAST_EDGE - rw, SEEY - 3 ),
                                              dat.zlevel(), 3 );
                            } else {
                                ter_set( point( SEEX + int( SEEX / 2 ), SEEY - 2 ), t_door_glass_frosted_c );
                                science_room( this, point( SEEX + 2, tw ), point( EAST_EDGE - rw, SEEY - 3 ),
                                              dat.zlevel(), 2 );
                            }
                            // Bottom left
                            if( one_in( 2 ) ) {
                                ter_set( point( SEEX / 2, SEEY + 1 ), t_door_glass_frosted_c );
                                science_room( this, point( lw, SEEY + 2 ), point( SEEX - 3, SOUTH_EDGE - bw ),
                                              dat.zlevel(), 0 );
                            } else {
                                ter_set( point( SEEX - 2, SEEY + int( SEEY / 2 ) ), t_door_glass_frosted_c );
                                science_room( this, point( lw, SEEY + 2 ), point( SEEX - 3, SOUTH_EDGE - bw ),
                                              dat.zlevel(), 1 );
                            }
                            // Bottom right
                            if( one_in( 2 ) ) {
                                ter_set( point( SEEX + int( SEEX / 2 ), SEEY + 1 ), t_door_glass_frosted_c );
                                science_room( this, point( SEEX + 2, SEEY + 2 ), point( EAST_EDGE - rw, SOUTH_EDGE - bw ),
                                              dat.zlevel(), 0 );
                            } else {
                                ter_set( point( SEEX + 1, SEEY + int( SEEY / 2 ) ), t_door_glass_frosted_c );
                                science_room( this, point( SEEX + 2, SEEY + 2 ), point( EAST_EDGE - rw, SOUTH_EDGE - bw ),
                                              dat.zlevel(), 3 );
                            }
                            if( rw == 1 ) {
                                ter_set( point( EAST_EDGE, SEEY - 1 ), t_door_metal_c );
                                ter_set( point( EAST_EDGE, SEEY ), t_door_metal_c );
                            }
                            if( bw == 1 ) {
                                ter_set( point( SEEX - 1, SOUTH_EDGE ), t_door_metal_c );
                                ter_set( point( SEEX, SOUTH_EDGE ), t_door_metal_c );
                            }
                            if( is_ot_match( "stairs", terrain_type, ot_match_type::contains ) ) { // Stairs going down
                                std::vector<point> stair_points;
                                if( tw != 0 ) {
                                    stair_points.push_back( point( SEEX - 1, 2 ) );
                                    stair_points.push_back( point( SEEX - 1, 2 ) );
                                    stair_points.push_back( point( SEEX, 2 ) );
                                    stair_points.push_back( point( SEEX, 2 ) );
                                }
                                if( rw != 1 ) {
                                    stair_points.push_back( point( SEEX * 2 - 3, SEEY - 1 ) );
                                    stair_points.push_back( point( SEEX * 2 - 3, SEEY - 1 ) );
                                    stair_points.push_back( point( SEEX * 2 - 3, SEEY ) );
                                    stair_points.push_back( point( SEEX * 2 - 3, SEEY ) );
                                }
                                if( bw != 1 ) {
                                    stair_points.push_back( point( SEEX - 1, SEEY * 2 - 3 ) );
                                    stair_points.push_back( point( SEEX - 1, SEEY * 2 - 3 ) );
                                    stair_points.push_back( point( SEEX, SEEY * 2 - 3 ) );
                                    stair_points.push_back( point( SEEX, SEEY * 2 - 3 ) );
                                }
                                if( lw != 0 ) {
                                    stair_points.push_back( point( 2, SEEY - 1 ) );
                                    stair_points.push_back( point( 2, SEEY - 1 ) );
                                    stair_points.push_back( point( 2, SEEY ) );
                                    stair_points.push_back( point( 2, SEEY ) );
                                }
                                stair_points.push_back( point( int( SEEX / 2 ), SEEY ) );
                                stair_points.push_back( point( int( SEEX / 2 ), SEEY - 1 ) );
                                stair_points.push_back( point( int( SEEX / 2 ) + SEEX, SEEY ) );
                                stair_points.push_back( point( int( SEEX / 2 ) + SEEX, SEEY - 1 ) );
                                stair_points.push_back( point( SEEX, int( SEEY / 2 ) ) );
                                stair_points.push_back( point( SEEX + 2, int( SEEY / 2 ) ) );
                                stair_points.push_back( point( SEEX, int( SEEY / 2 ) + SEEY ) );
                                stair_points.push_back( point( SEEX + 2, int( SEEY / 2 ) + SEEY ) );
                                const point p = random_entry( stair_points );
                                ter_set( p, t_stairs_down );
                            }
 
                            break;
 
                        case 2:
                            // tic-tac-toe # layout
                            for( int i = 0; i < SEEX * 2; i++ ) {
                                for( int j = 0; j < SEEY * 2; j++ ) {
                                    if( i < lw || i > EAST_EDGE - rw || i == SEEX - 4 ||
                                        i == SEEX + 3 ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else if( j < tw || j > SOUTH_EDGE - bw || j == SEEY - 4 ||
                                               j == SEEY + 3 ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else {
                                        ter_set( point( i, j ), t_thconc_floor );
                                    }
                                }
                            }
                            if( is_ot_match( "stairs", dat.above(), ot_match_type::contains ) ) {
                                ter_set( point( SEEX - 1, SEEY - 1 ), t_stairs_up );
                                ter_set( point( SEEX, SEEY - 1 ), t_stairs_up );
                                ter_set( point( SEEX - 1, SEEY ), t_stairs_up );
                                ter_set( point( SEEX, SEEY ), t_stairs_up );
                            }
                            ter_set( point( SEEX - rng( 0, 1 ), SEEY - 4 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX - rng( 0, 1 ), SEEY + 3 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX - 4, SEEY + rng( 0, 1 ) ), t_door_glass_frosted_c );
                            ter_set( point( SEEX + 3, SEEY + rng( 0, 1 ) ), t_door_glass_frosted_c );
                            ter_set( point( SEEX - 4, int( SEEY / 2 ) ), t_door_glass_frosted_c );
                            ter_set( point( SEEX + 3, int( SEEY / 2 ) ), t_door_glass_frosted_c );
                            ter_set( point( SEEX / 2, SEEY - 4 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX / 2, SEEY + 3 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX + int( SEEX / 2 ), SEEY - 4 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX + int( SEEX / 2 ), SEEY + 3 ), t_door_glass_frosted_c );
                            ter_set( point( SEEX - 4, SEEY + int( SEEY / 2 ) ), t_door_glass_frosted_c );
                            ter_set( point( SEEX + 3, SEEY + int( SEEY / 2 ) ), t_door_glass_frosted_c );
                            science_room( this, point( lw, tw ), point( SEEX - 5, SEEY - 5 ), dat.zlevel(),
                                          rng( 1, 2 ) );
                            science_room( this, point( SEEX - 3, tw ), point( SEEX + 2, SEEY - 5 ), dat.zlevel(), 2 );
                            science_room( this, point( SEEX + 4, tw ), point( EAST_EDGE - rw, SEEY - 5 ),
                                          dat.zlevel(), rng( 2, 3 ) );
                            science_room( this, point( lw, SEEY - 3 ), point( SEEX - 5, SEEY + 2 ), dat.zlevel(), 1 );
                            science_room( this, point( SEEX + 4, SEEY - 3 ), point( EAST_EDGE - rw, SEEY + 2 ),
                                          dat.zlevel(), 3 );
                            science_room( this, point( lw, SEEY + 4 ), point( SEEX - 5, SOUTH_EDGE - bw ),
                                          dat.zlevel(), rng( 0, 1 ) );
                            science_room( this, point( SEEX - 3, SEEY + 4 ), point( SEEX + 2, SOUTH_EDGE - bw ),
                                          dat.zlevel(), 0 );
                            science_room( this, point( SEEX + 4, SEEX + 4 ), point( EAST_EDGE - rw, SOUTH_EDGE - bw ),
                                          dat.zlevel(), 3 * rng( 0, 1 ) );
                            if( rw == 1 ) {
                                ter_set( point( EAST_EDGE, SEEY - 1 ), t_door_metal_c );
                                ter_set( point( EAST_EDGE, SEEY ), t_door_metal_c );
                            }
                            if( bw == 1 ) {
                                ter_set( point( SEEX - 1, SOUTH_EDGE ), t_door_metal_c );
                                ter_set( point( SEEX, SOUTH_EDGE ), t_door_metal_c );
                            }
                            if( is_ot_match( "stairs", terrain_type, ot_match_type::contains ) ) {
                                ter_set( point( SEEX - 3 + 5 * rng( 0, 1 ), SEEY - 3 + 5 * rng( 0, 1 ) ),
                                         t_stairs_down );
                            }
                            break;
 
                        case 3:
                            // Big room
                            for( int i = 0; i < SEEX * 2; i++ ) {
                                for( int j = 0; j < SEEY * 2; j++ ) {
                                    if( i < lw || i >= EAST_EDGE - rw ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else if( j < tw || j >= SOUTH_EDGE - bw ) {
                                        ter_set( point( i, j ), t_concrete_wall );
                                    } else {
                                        ter_set( point( i, j ), t_thconc_floor );
                                    }
                                }
                            }
                            science_room( this, point( lw, tw ), point( EAST_EDGE - rw, SOUTH_EDGE - bw ),
                                          dat.zlevel(), rng( 0, 3 ) );
 
                            if( rw == 1 ) {
                                ter_set( point( EAST_EDGE, SEEY - 1 ), t_door_metal_c );
                                ter_set( point( EAST_EDGE, SEEY ), t_door_metal_c );
                            }
                            if( bw == 1 ) {
                                ter_set( point( SEEX - 1, SOUTH_EDGE ), t_door_metal_c );
                                ter_set( point( SEEX, SOUTH_EDGE ), t_door_metal_c );
                            }
                            maybe_insert_stairs( dat.above(), t_stairs_up );
                            maybe_insert_stairs( terrain_type, t_stairs_down );
                            break;
                    }
                } // endif use_hardcoded_4side_map
            }  // end 1 vs 4 sides
        } // end aboveground vs belowground
 
        // Ants will totally wreck up the place
        if( is_ot_match( "ants", terrain_type, ot_match_type::contains ) ) {
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    // Carve out a diamond area that covers 2 spaces on each edge.
                    if( i + j > 10 && i + j < 36 && std::abs( i - j ) < 13 ) {
                        // Doors and walls get sometimes destroyed:
                        // 100% at the edge, usually in a central cross, occasionally elsewhere.
                        if( ( has_flag_ter( "DOOR", point( i, j ) ) || has_flag_ter( "WALL", point( i, j ) ) ) ) {
                            if( ( i == 0 || j == 0 || i == 23 || j == 23 ) ||
                                ( !one_in( 3 ) && ( i == 11 || i == 12 || j == 11 || j == 12 ) ) ||
                                one_in( 4 ) ) {
                                // bash and usually remove the rubble.
                                make_rubble( { i, j, abs_sub.z } );
                                ter_set( point( i, j ), t_rock_floor );
                                if( !one_in( 3 ) ) {
                                    furn_set( point( i, j ), f_null );
                                }
                            }
                            // and then randomly destroy 5% of the remaining nonstairs.
                        } else if( one_in( 20 ) &&
                                   !has_flag_ter( "GOES_DOWN", p2 ) &&
                                   !has_flag_ter( "GOES_UP", p2 ) ) {
                            destroy( { i, j, abs_sub.z } );
                            // bashed squares can create dirt & floors, but we want rock floors.
                            if( t_dirt == ter( point( i, j ) ) || t_floor == ter( point( i, j ) ) ) {
                                ter_set( point( i, j ), t_rock_floor );
                            }
                        }
                    }
                }
            }
        }
 
        // Slimes pretty much wreck up the place, too, but only underground
        tw = ( dat.north() == "slimepit" ? SEEY     : 0 );
        rw = ( dat.east()  == "slimepit" ? SEEX + 1 : 0 );
        bw = ( dat.south() == "slimepit" ? SEEY + 1 : 0 );
        lw = ( dat.west()  == "slimepit" ? SEEX     : 0 );
        if( tw != 0 || rw != 0 || bw != 0 || lw != 0 ) {
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    if( ( ( j <= tw || i >= rw ) && i >= j && ( EAST_EDGE - i ) <= j ) ||
                        ( ( j >= bw || i <= lw ) && i <= j && ( SOUTH_EDGE - j ) <= i ) ) {
                        if( one_in( 5 ) ) {
                            make_rubble( tripoint( i,  j, abs_sub.z ), f_rubble_rock,
                                         t_slime );
                        } else if( !one_in( 5 ) ) {
                            ter_set( point( i, j ), t_slime );
                        }
                    }
                }
            }
        }
 
        int light_odds = 0;
        // central labs are always fully lit, other labs have half chance of some lights.
        if( central_lab ) {
            light_odds = 1;
        } else if( one_in( 2 ) ) {
            // Create a spread of densities, from all possible lights on, to 1/3, ...
            // to ~1 per segment.
            light_odds = std::pow( rng( 1, 12 ), 1.6 );
        }
        if( light_odds > 0 ) {
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    if( !( ( i * j ) % 2 || ( i + j ) % 4 ) && one_in( light_odds ) ) {
                        if( t_thconc_floor == ter( point( i, j ) ) || t_strconc_floor == ter( point( i, j ) ) ) {
                            ter_set( point( i, j ), t_thconc_floor_olight );
                        }
                    }
                }
            }
        }
 
        if( tower_lab ) {
            place_spawns( GROUP_LAB, 1, point_zero, point( EAST_EDGE, EAST_EDGE ), abs_sub.z * 0.02f );
        }
 
        // Lab special effects.
        if( one_in( 10 ) ) {
            switch( rng( 1, 7 ) ) {
                // full flooding/sewage
                case 1: {
                    if( is_ot_match( "stairs", terrain_type, ot_match_type::contains ) ||
                        is_ot_match( "ice", terrain_type, ot_match_type::contains ) ) {
                        // don't flood if stairs because the floor below will not be flooded.
                        // don't flood if ice lab because there's no mechanic for freezing
                        // liquid floors.
                        break;
                    }
                    auto fluid_type = one_in( 3 ) ? t_sewage : t_water_sh;
                    for( int i = 0; i < EAST_EDGE; i++ ) {
                        for( int j = 0; j < SOUTH_EDGE; j++ ) {
                            // We spare some terrain to make it look better visually.
                            if( !one_in( 10 ) && ( t_thconc_floor == ter( point( i, j ) ) ||
                                                   t_strconc_floor == ter( point( i, j ) ) ||
                                                   t_thconc_floor_olight == ter( point( i, j ) ) ) ) {
                                ter_set( point( i, j ), fluid_type );
                            } else if( has_flag_ter( "DOOR", point( i, j ) ) && !one_in( 3 ) ) {
                                // We want the actual debris, but not the rubble marker or dirt.
                                make_rubble( { i, j, abs_sub.z } );
                                ter_set( point( i, j ), fluid_type );
                                furn_set( point( i, j ), f_null );
                            }
                        }
                    }
                    break;
                }
                // minor flooding/sewage
                case 2: {
                    if( is_ot_match( "stairs", terrain_type, ot_match_type::contains ) ||
                        is_ot_match( "ice", terrain_type, ot_match_type::contains ) ) {
                        // don't flood if stairs because the floor below will not be flooded.
                        // don't flood if ice lab because there's no mechanic for freezing
                        // liquid floors.
                        break;
                    }
                    auto fluid_type = one_in( 3 ) ? t_sewage : t_water_sh;
                    for( int i = 0; i < 2; ++i ) {
                        draw_rough_circle( [this, fluid_type]( point  p ) {
                            if( t_thconc_floor == ter( p ) || t_strconc_floor == ter( p ) ||
                                t_thconc_floor_olight == ter( p ) ) {
                                ter_set( p, fluid_type );
                            } else if( has_flag_ter( "DOOR", p ) ) {
                                // We want the actual debris, but not the rubble marker or dirt.
                                make_rubble( { p, abs_sub.z } );
                                ter_set( p, fluid_type );
                                furn_set( p, f_null );
                            }
                        }, point( rng( 1, SEEX * 2 - 2 ), rng( 1, SEEY * 2 - 2 ) ), rng( 3, 6 ) );
                    }
                    break;
                }
                // toxic gas leaks and smoke-filled rooms.
                case 3:
                case 4: {
                    bool is_toxic = one_in( 3 );
                    for( int i = 0; i < SEEX * 2; i++ ) {
                        for( int j = 0; j < SEEY * 2; j++ ) {
                            if( one_in( 200 ) && ( t_thconc_floor == ter( point( i, j ) ) ||
                                                   t_strconc_floor == ter( point( i, j ) ) ) ) {
                                if( is_toxic ) {
                                    add_field( {i, j, abs_sub.z}, fd_gas_vent, 1 );
                                } else {
                                    add_field( {i, j, abs_sub.z}, fd_smoke_vent, 2 );
                                }
                            }
                        }
                    }
                    break;
                }
                // portal with an artifact effect.
                case 5: {
                    tripoint center( rng( 6, SEEX * 2 - 7 ), rng( 6, SEEY * 2 - 7 ), abs_sub.z );
                    std::vector<artifact_natural_property> valid_props = {
                        ARTPROP_BREATHING,
                        ARTPROP_CRACKLING,
                        ARTPROP_WARM,
                        ARTPROP_SCALED,
                        ARTPROP_WHISPERING,
                        ARTPROP_GLOWING
                    };
                    draw_rough_circle( [this]( point  p ) {
                        if( has_flag_ter( "GOES_DOWN", p ) ||
                            has_flag_ter( "GOES_UP", p ) ||
                            has_flag_ter( "CONSOLE", p ) ) {
                            return; // spare stairs and consoles.
                        }
                        make_rubble( {p, abs_sub.z } );
                        ter_set( p, t_thconc_floor );
                    }, center.xy(), 4 );
                    furn_set( center.xy(), f_null );
                    trap_set( center, tr_portal );
                    create_anomaly( center, random_entry( valid_props ), false );
                    break;
                }
                // radioactive accident.
                case 6: {
                    tripoint center( rng( 6, SEEX * 2 - 7 ), rng( 6, SEEY * 2 - 7 ), abs_sub.z );
                    if( has_flag_ter( "WALL", center.xy() ) ) {
                        // just skip it, we don't want to risk embedding radiation out of sight.
                        break;
                    }
                    draw_rough_circle( [this]( point  p ) {
                        set_radiation( p, 10 );
                    }, center.xy(), rng( 7, 12 ) );
                    draw_circle( [this]( point  p ) {
                        set_radiation( p, 20 );
                    }, center.xy(), rng( 5, 8 ) );
                    draw_circle( [this]( point  p ) {
                        set_radiation( p, 30 );
                    }, center.xy(), rng( 2, 4 ) );
                    draw_circle( [this]( point  p ) {
                        set_radiation( p, 50 );
                    }, center.xy(), 1 );
                    draw_circle( [this]( point  p ) {
                        if( has_flag_ter( "GOES_DOWN", p ) ||
                            has_flag_ter( "GOES_UP", p ) ||
                            has_flag_ter( "CONSOLE", p ) ) {
                            return; // spare stairs and consoles.
                        }
                        make_rubble( {p, abs_sub.z } );
                        ter_set( p, t_thconc_floor );
                    }, center.xy(), 1 );
 
                    place_spawns( GROUP_HAZMATBOT, 1, center.xy() + point_west,
                                  center.xy() + point_west, 1, true );
                    place_spawns( GROUP_HAZMATBOT, 2, center.xy() + point_west,
                                  center.xy() + point_west, 1, true );
 
                    // damaged mininuke/plut thrown past edge of rubble so the player can see it.
                    int marker_x = center.x - 2 + 4 * rng( 0, 1 );
                    int marker_y = center.y + rng( -2, 2 );
                    if( one_in( 4 ) ) {
                        spawn_item(
                            point( marker_x, marker_y ), "mininuke", 1, 1, calendar::start_of_cataclysm, rng( 2, 4 )
                        );
                    } else {
                        item newliquid( "plut_slurry_dense", calendar::start_of_cataclysm );
                        newliquid.charges = 1;
                        add_item_or_charges( tripoint( marker_x, marker_y, get_abs_sub().z ),
                                             newliquid );
                    }
                    break;
                }
                // portal with fungal invasion
                case 7: {
                    for( int i = 0; i < EAST_EDGE; i++ ) {
                        for( int j = 0; j < SOUTH_EDGE; j++ ) {
                            // Create a mostly spread fungal area throughout entire lab.
                            if( !one_in( 5 ) && ( has_flag( "FLAT", point( i, j ) ) ) ) {
                                ter_set( point( i, j ), t_fungus_floor_in );
                                if( has_flag_furn( "ORGANIC", point( i, j ) ) ) {
                                    furn_set( point( i, j ), f_fungal_clump );
                                }
                            } else if( has_flag_ter( "DOOR", point( i, j ) ) && !one_in( 5 ) ) {
                                ter_set( point( i, j ), t_fungus_floor_in );
                            } else if( has_flag_ter( "WALL", point( i, j ) ) && one_in( 3 ) ) {
                                ter_set( point( i, j ), t_fungus_wall );
                            }
                        }
                    }
                    tripoint center( rng( 6, SEEX * 2 - 7 ), rng( 6, SEEY * 2 - 7 ), abs_sub.z );
 
                    // Make a portal surrounded by more dense fungal stuff and a fungaloid.
                    draw_rough_circle( [this]( point  p ) {
                        if( has_flag_ter( "GOES_DOWN", p ) ||
                            has_flag_ter( "GOES_UP", p ) ||
                            has_flag_ter( "CONSOLE", p ) ) {
                            return; // spare stairs and consoles.
                        }
                        if( has_flag_ter( "WALL", p ) ) {
                            ter_set( p, t_fungus_wall );
                        } else {
                            ter_set( p, t_fungus_floor_in );
                            if( one_in( 3 ) ) {
                                furn_set( p, f_flower_fungal );
                            } else if( one_in( 10 ) ) {
                                ter_set( p, t_marloss );
                            }
                        }
                    }, center.xy(), 3 );
                    ter_set( center.xy(), t_fungus_floor_in );
                    furn_set( center.xy(), f_null );
                    trap_set( center, tr_portal );
                    place_spawns( GROUP_FUNGI_FUNGALOID, 1, center.xy() + point( -2, -2 ),
                                  center.xy() + point( 2, 2 ), 1, true );
 
                    break;
                }
            }
        }
    } else if( terrain_type == "lab_finale" || terrain_type == "ice_lab_finale" ||
               terrain_type == "central_lab_finale" || terrain_type == "tower_lab_finale" ) {
 
        ice_lab = is_ot_match( "ice_lab", terrain_type, ot_match_type::prefix );
        central_lab = is_ot_match( "central_lab", terrain_type, ot_match_type::prefix );
        tower_lab = is_ot_match( "tower_lab", terrain_type, ot_match_type::prefix );
 
        if( ice_lab ) {
            int temperature = -20 + 30 * dat.zlevel();
            set_temperature( p2, temperature );
            set_temperature( p2 + point( SEEX, 0 ), temperature );
            set_temperature( p2 + point( 0, SEEY ), temperature );
            set_temperature( p2 + point( SEEX, SEEY ), temperature );
        }
 
        tw = is_ot_match( "lab", dat.north(), ot_match_type::contains ) ? 0 : 2;
        rw = is_ot_match( "lab", dat.east(), ot_match_type::contains ) ? 1 : 2;
        bw = is_ot_match( "lab", dat.south(), ot_match_type::contains ) ? 1 : 2;
        lw = is_ot_match( "lab", dat.west(), ot_match_type::contains ) ? 0 : 2;
 
        // If you remove the usage of "lab_finale_1level" here, remove it from mapgen_factory::get_usages above as well.
        if( oter_mapgen.generate( dat, "lab_finale_1level" ) ) {
            // If the map template hasn't handled borders, handle them in code.
            // Rotated maps cannot handle borders and have to be caught in code.
            // We determine if a border isn't handled by checking the east-facing
            // border space where the door normally is -- it should be a wall or door.
            tripoint east_border( 23, 11, abs_sub.z );
            if( !has_flag_ter( "WALL", east_border ) && !has_flag_ter( "DOOR", east_border ) ) {
                // TODO: create a ter_reset function that does ter_set, furn_set, and i_clear?
                ter_id lw_type = tower_lab ? t_reinforced_glass : t_concrete_wall;
                ter_id tw_type = tower_lab ? t_reinforced_glass : t_concrete_wall;
                ter_id rw_type = tower_lab && rw == 2 ? t_reinforced_glass : t_concrete_wall;
                ter_id bw_type = tower_lab && bw == 2 ? t_reinforced_glass : t_concrete_wall;
                for( int i = 0; i < SEEX * 2; i++ ) {
                    ter_set( point( 23, i ), rw_type );
                    furn_set( point( 23, i ), f_null );
                    i_clear( tripoint( 23, i, get_abs_sub().z ) );
 
                    ter_set( point( i, 23 ), bw_type );
                    furn_set( point( i, 23 ), f_null );
                    i_clear( tripoint( i, 23, get_abs_sub().z ) );
 
                    if( lw == 2 ) {
                        ter_set( point( 0, i ), lw_type );
                        furn_set( point( 0, i ), f_null );
                        i_clear( tripoint( 0, i, get_abs_sub().z ) );
                    }
                    if( tw == 2 ) {
                        ter_set( point( i, 0 ), tw_type );
                        furn_set( point( i, 0 ), f_null );
                        i_clear( tripoint( i, 0, get_abs_sub().z ) );
                    }
                }
                if( rw != 2 ) {
                    ter_set( point( 23, 11 ), t_door_metal_c );
                    ter_set( point( 23, 12 ), t_door_metal_c );
                }
                if( bw != 2 ) {
                    ter_set( point( 11, 23 ), t_door_metal_c );
                    ter_set( point( 12, 23 ), t_door_metal_c );
                }
            }
        }
 
        // Handle stairs in the unlikely case they are needed.
        const auto maybe_insert_stairs = [this]( const oter_id & terrain,  const ter_id & t_stair_type ) {
            if( is_ot_match( "stairs", terrain, ot_match_type::contains ) ) {
                const auto predicate = [this]( const tripoint & p ) {
                    return ter( p ) == t_thconc_floor && furn( p ) == f_null &&
                           tr_at( p ).is_null();
                };
                const auto range = points_in_rectangle( { 0, 0, abs_sub.z },
                { SEEX * 2 - 2, SEEY * 2 - 2, abs_sub.z } );
                if( const auto p = random_point( range, predicate ) ) {
                    ter_set( *p, t_stair_type );
                }
            }
        };
        maybe_insert_stairs( dat.above(), t_stairs_up );
        maybe_insert_stairs( terrain_type, t_stairs_down );
 
        int light_odds = 0;
        // central labs are always fully lit, other labs have half chance of some lights.
        if( central_lab ) {
            light_odds = 1;
        } else if( one_in( 2 ) ) {
            light_odds = std::pow( rng( 1, 12 ), 1.6 );
        }
        if( light_odds > 0 ) {
            for( int i = 0; i < SEEX * 2; i++ ) {
                for( int j = 0; j < SEEY * 2; j++ ) {
                    if( !( ( i * j ) % 2 || ( i + j ) % 4 ) && one_in( light_odds ) ) {
                        if( t_thconc_floor == ter( point( i, j ) ) || t_strconc_floor == ter( point( i, j ) ) ) {
                            ter_set( point( i, j ), t_thconc_floor_olight );
                        }
                    }
                }
            }
        }
    }
}

References mapgendata::above(), abs_sub, add_field(), add_item_or_charges(), ARTPROP_BREATHING, ARTPROP_CRACKLING, ARTPROP_GLOWING, ARTPROP_SCALED, ARTPROP_WARM, ARTPROP_WHISPERING, center, item::charges, connects_to(), contains, create_anomaly(), debugmsg, destroy(), draw_circle(), draw_rough_circle(), mapgendata::east(), EAST_EDGE, f_flower_fungal, f_fungal_clump, f_null, f_rubble_rock, fd_gas_vent, fd_smoke_vent, furn(), furn_set(), mapgen_factory::generate(), get_abs_sub(), GROUP_FUNGI_FUNGALOID, GROUP_HAZMATBOT, GROUP_LAB, GROUP_TURRET, has_flag(), has_flag_furn(), has_flag_ter(), i_clear(), trap::is_null(), is_ot_match(), make_rubble(), mapgendata::north(), one_in(), oter_mapgen, place_spawns(), point_west, point_zero, points_in_rectangle(), prefix, random_entry(), random_point(), range, rng(), rotate(), science_room(), SEEX, SEEY, set_radiation(), set_temperature(), mapgendata::south(), SOUTH_EDGE, spawn_item(), calendar::start_of_cataclysm, t_bars, t_card_science, t_concrete_wall, t_dirt, t_door_glass_frosted_c, t_door_metal_c, t_door_metal_locked, t_floor, t_fungus_floor_in, t_fungus_wall, t_marloss, t_reinforced_glass, t_rock_floor, t_sewage, t_slime, t_stairs_down, t_stairs_up, t_strconc_floor, t_thconc_floor, t_thconc_floor_olight, t_water_sh, ter(), ter_set(), terrain, mapgendata::terrain_type(), tr_at(), tr_portal, trap_set(), type, mapgendata::west(), tripoint::z, and mapgendata::zlevel().

Referenced by draw_map().

◆ draw_line_furn()

void map::draw_line_furn	(	const furn_id &	type,
		point	p1,
		point	p2
	)

Definition at line 8504 of file map.cpp.

{
    draw_line( [this, type]( point  p ) {
        this->furn_set( p, type );
    }, p1, p2 );
}

References draw_line(), furn_set(), and type.

Referenced by jmapgen_setmap::apply(), and line_furn().

◆ draw_line_ter()

void map::draw_line_ter	(	const ter_id &	type,
		point	p1,
		point	p2
	)

Definition at line 8497 of file map.cpp.

{
    draw_line( [this, type]( point  p ) {
        this->ter_set( p, type );
    }, p1, p2 );
}

References draw_line(), ter_set(), and type.

Referenced by jmapgen_setmap::apply(), and line().

◆ draw_map()

void map::draw_map ( mapgendata & dat )

protected

Definition at line 2922 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    const std::string function_key = terrain_type->get_mapgen_id();
    bool found = true;
 
    const bool generated = run_mapgen_func( function_key, dat );
 
    if( !generated ) {
        if( is_ot_match( "slimepit", terrain_type, ot_match_type::prefix ) ||
            is_ot_match( "slime_pit", terrain_type, ot_match_type::prefix ) ) {
            draw_slimepit( dat );
        } else if( is_ot_match( "triffid", terrain_type, ot_match_type::prefix ) ) {
            draw_triffid( dat );
        } else if( is_ot_match( "office", terrain_type, ot_match_type::prefix ) ) {
            draw_office_tower( dat );
        } else if( is_ot_match( "temple", terrain_type, ot_match_type::prefix ) ) {
            draw_temple( dat );
        } else if( is_ot_match( "mine", terrain_type, ot_match_type::prefix ) ) {
            draw_mine( dat );
        } else if( is_ot_match( "anthill", terrain_type, ot_match_type::contains ) ) {
            draw_anthill( dat );
        } else if( is_ot_match( "lab", terrain_type, ot_match_type::contains ) ) {
            draw_lab( dat );
        } else {
            found = false;
        }
    }
 
    if( !found ) {
        // not one of the hardcoded ones!
        // load from JSON???
        debugmsg( "Error: tried to generate map for omtype %s, \"%s\" (id_mapgen %s)",
                  terrain_type.id().c_str(), terrain_type->get_name(), function_key.c_str() );
        fill_background( this, t_floor );
    }
 
    draw_connections( dat );
}

References string_id< T >::c_str(), contains, debugmsg, draw_anthill(), draw_connections(), draw_lab(), draw_mine(), draw_office_tower(), draw_slimepit(), draw_temple(), draw_triffid(), fill_background(), oter_t::get_mapgen_id(), oter_t::get_name(), int_id< T >::id(), is_ot_match(), prefix, run_mapgen_func(), t_floor, and mapgendata::terrain_type().

Referenced by generate().

◆ draw_maptile()

bool map::draw_maptile	(	const catacurses::window &	w,
		const tripoint &	p,
		const maptile &	tile,
		const drawsq_params &	params
	)		const

private

Internal version of the drawsq.

Keeps a cached maptile for less re-getting. Returns false if it has drawn all it should, true if draw_from_above should be called after.

Definition at line 6005 of file map.cpp.

{
    drawsq_params param = params;
    nc_color tercol;
    const ter_t &curr_ter = curr_maptile.get_ter_t();
    const furn_t &curr_furn = curr_maptile.get_furn_t();
    const trap &curr_trap = curr_maptile.get_trap().obj();
    const field &curr_field = curr_maptile.get_field();
    int sym;
    bool hi = false;
    bool graf = false;
    bool draw_item_sym = false;
 
    int terrain_sym;
    if( curr_ter.has_flag( TFLAG_AUTO_WALL_SYMBOL ) ) {
        terrain_sym = determine_wall_corner( p );
    } else {
        terrain_sym = curr_ter.symbol();
    }
 
    if( curr_furn.id ) {
        sym = curr_furn.symbol();
        tercol = curr_furn.color();
    } else {
        sym = terrain_sym;
        tercol = curr_ter.color();
    }
    if( curr_ter.has_flag( TFLAG_SWIMMABLE ) && curr_ter.has_flag( TFLAG_DEEP_WATER ) &&
        !g->u.is_underwater() ) {
        param.show_items( false ); // Can only see underwater items if WE are underwater
    }
    // If there's a trap here, and we have sufficient perception, draw that instead
    if( curr_trap.can_see( p, g->u ) ) {
        tercol = curr_trap.color;
        if( curr_trap.sym == '%' ) {
            switch( rng( 1, 5 ) ) {
                case 1:
                    sym = '*';
                    break;
                case 2:
                    sym = '0';
                    break;
                case 3:
                    sym = '8';
                    break;
                case 4:
                    sym = '&';
                    break;
                case 5:
                    sym = '+';
                    break;
            }
        } else {
            sym = curr_trap.sym;
        }
    }
    if( curr_field.field_count() > 0 ) {
        const field_type_id &fid = curr_field.displayed_field_type();
        const field_entry *fe = curr_field.find_field( fid );
        const auto field_symbol = fid->get_symbol();
        if( field_symbol == "&" || fe == nullptr ) {
            // Do nothing, a '&' indicates invisible fields.
        } else if( field_symbol == "*" ) {
            // A random symbol.
            switch( rng( 1, 5 ) ) {
                case 1:
                    sym = '*';
                    break;
                case 2:
                    sym = '0';
                    break;
                case 3:
                    sym = '8';
                    break;
                case 4:
                    sym = '&';
                    break;
                case 5:
                    sym = '+';
                    break;
            }
        } else {
            // A field symbol '%' indicates the field should not hide
            // items/terrain. When the symbol is not '%' it will
            // hide items (the color is still inverted if there are items,
            // but the tile symbol is not changed).
            // draw_item_sym indicates that the item symbol should be used
            // even if sym is not '.'.
            // As we don't know at this stage if there are any items
            // (that are visible to the player!), we always set the symbol.
            // If there are items and the field does not hide them,
            // the code handling items will override it.
            draw_item_sym = ( field_symbol == "'%" );
            // If field display_priority is > 1, and the field is set to hide items,
            //draw the field as it obscures what's under it.
            if( ( field_symbol != "%" && fid.obj().priority > 1 ) || ( field_symbol != "%" &&
                    sym == '.' ) )  {
                // default terrain '.' and
                // non-default field symbol -> field symbol overrides terrain
                sym = field_symbol[0];
            }
            tercol = fe->color();
        }
    }
 
    // TODO: change the local variable sym to std::string and use it instead of this hack.
    // Currently this are different variables because terrain/... uses int as symbol type and
    // item now use string. Ideally they should all be strings.
    std::string item_sym;
 
    // If there are items here, draw those instead
    if( param.show_items() && curr_maptile.get_item_count() > 0 && sees_some_items( p, g->u ) ) {
        // if there's furniture/terrain/trap/fields (sym!='.')
        // and we should not override it, then only highlight the square
        if( sym != '.' && sym != '%' && !draw_item_sym ) {
            hi = true;
        } else {
            // otherwise override with the symbol of the last item
            item_sym = curr_maptile.get_uppermost_item().symbol();
            if( !draw_item_sym ) {
                tercol = curr_maptile.get_uppermost_item().color();
            }
            if( curr_maptile.get_item_count() > 1 ) {
                param.highlight( !param.highlight() );
            }
        }
    }
 
    int memory_sym = sym;
    int veh_part = 0;
    const vehicle *veh = veh_at_internal( p, veh_part );
    if( veh != nullptr ) {
        sym = special_symbol( veh->face.dir_symbol( veh->part_sym( veh_part ) ) );
        tercol = veh->part_color( veh_part );
        item_sym.clear(); // clear the item symbol so `sym` is used instead.
 
        if( !veh->forward_velocity() && !veh->player_in_control( g->u ) ) {
            memory_sym = sym;
        }
    }
 
    if( param.memorize() && check_and_set_seen_cache( p ) ) {
        g->u.memorize_symbol( getabs( p ), memory_sym );
    }
 
    // If there's graffiti here, change background color
    if( curr_maptile.has_graffiti() ) {
        graf = true;
    }
 
    const auto u_vision = g->u.get_vision_modes();
    if( u_vision[BOOMERED] ) {
        tercol = c_magenta;
    } else if( u_vision[NV_GOGGLES] ) {
        tercol = param.bright_light() ? c_white : c_light_green;
    } else if( param.low_light() ) {
        tercol = c_dark_gray;
    } else if( u_vision[DARKNESS] ) {
        tercol = c_dark_gray;
    }
 
    if( param.highlight() ) {
        tercol = invert_color( tercol );
    } else if( hi ) {
        tercol = hilite( tercol );
    } else if( graf ) {
        tercol = red_background( tercol );
    }
 
    if( item_sym.empty() && sym == ' ' ) {
        if( !zlevels || p.z <= -OVERMAP_DEPTH || !curr_ter.has_flag( TFLAG_NO_FLOOR ) ) {
            // Print filler symbol
            sym = ' ';
            tercol = c_black;
        } else {
            // Draw tile underneath this one instead
            return false;
        }
    }
 
    if( params.output() ) {
        if( item_sym.empty() ) {
            wputch( w, tercol, sym );
        } else {
            wprintz( w, tercol, item_sym );
        }
    }
    return true;
}

References BOOMERED, drawsq_params::bright_light(), c_black, c_dark_gray, c_light_green, c_magenta, c_white, trap::can_see(), check_and_set_seen_cache(), field_entry::color(), item::color(), map_data_common_t::color(), trap::color, DARKNESS, determine_wall_corner(), tileray::dir_symbol(), field::displayed_field_type(), vehicle::face, field::field_count(), field::find_field(), vehicle::forward_velocity(), g, maptile::get_field(), maptile::get_furn_t(), maptile::get_item_count(), field_type::get_symbol(), maptile::get_ter_t(), maptile::get_trap(), maptile::get_uppermost_item(), getabs(), map_data_common_t::has_flag(), maptile::has_graffiti(), drawsq_params::highlight(), hilite(), furn_t::id, invert_color(), drawsq_params::low_light(), drawsq_params::memorize(), NV_GOGGLES, int_id< T >::obj(), drawsq_params::output(), OVERMAP_DEPTH, vehicle::part_color(), vehicle::part_sym(), vehicle::player_in_control(), field_type::priority, red_background(), rng(), sees_some_items(), drawsq_params::show_items(), special_symbol(), trap::sym, item::symbol(), map_data_common_t::symbol(), TFLAG_AUTO_WALL_SYMBOL, TFLAG_DEEP_WATER, TFLAG_NO_FLOOR, TFLAG_SWIMMABLE, veh_at_internal(), wprintz(), wputch(), tripoint::z, and zlevels.

Referenced by draw(), and drawsq().

◆ draw_mine()

void map::draw_mine ( mapgendata & dat )

protected

Definition at line 4596 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( terrain_type == "mine" || terrain_type == "mine_down" ) {
        if( is_ot_match( "mine", dat.north(), ot_match_type::prefix ) ) {
            dat.n_fac = ( one_in( 10 ) ? 0 : -2 );
        } else {
            dat.n_fac = 4;
        }
        if( is_ot_match( "mine", dat.east(), ot_match_type::prefix ) ) {
            dat.e_fac = ( one_in( 10 ) ? 0 : -2 );
        } else {
            dat.e_fac = 4;
        }
        if( is_ot_match( "mine", dat.south(), ot_match_type::prefix ) ) {
            dat.s_fac = ( one_in( 10 ) ? 0 : -2 );
        } else {
            dat.s_fac = 4;
        }
        if( is_ot_match( "mine", dat.west(), ot_match_type::prefix ) ) {
            dat.w_fac = ( one_in( 10 ) ? 0 : -2 );
        } else {
            dat.w_fac = 4;
        }
 
        for( int i = 0; i < SEEX * 2; i++ ) {
            for( int j = 0; j < SEEY * 2; j++ ) {
                if( i >= dat.w_fac + rng( 0, 2 ) && i <= EAST_EDGE - dat.e_fac - rng( 0, 2 ) &&
                    j >= dat.n_fac + rng( 0, 2 ) && j <= SOUTH_EDGE - dat.s_fac - rng( 0, 2 ) &&
                    i + j >= 4 && ( SEEX * 2 - i ) + ( SEEY * 2 - j ) >= 6 ) {
                    ter_set( point( i, j ), t_rock_floor );
                } else {
                    ter_set( point( i, j ), t_rock );
                }
            }
        }
 
        // Not an entrance; maybe some hazards!
        switch( rng( 0, 4 ) ) {
            case 0:
                break; // Nothing!  Lucky!
 
            case 1: {
                // Toxic gas
                point gas_vent_location( rng( 9, 14 ), rng( 9, 14 ) );
                ter_set( point( gas_vent_location ), t_rock );
                add_field( { gas_vent_location, abs_sub.z }, fd_gas_vent, 2 );
            }
            break;
 
            case 2: {
                // Lava
                point start_location( rng( 6, SEEX ), rng( 6, SEEY ) );
                point end_location( rng( SEEX + 1, SEEX * 2 - 7 ), rng( SEEY + 1, SEEY * 2 - 7 ) );
                const int num = rng( 2, 4 );
                for( int i = 0; i < num; i++ ) {
                    int lx1 = start_location.x + rng( -1, 1 );
                    int lx2 = end_location.x + rng( -1, 1 );
                    int ly1 = start_location.y + rng( -1, 1 );
                    int ly2 = end_location.y + rng( -1, 1 );
                    line( this, t_lava, point( lx1, ly1 ), point( lx2, ly2 ) );
                }
                for( const tripoint &ore : points_in_rectangle( tripoint( start_location, abs_sub.z ),
                        tripoint( end_location,
                                  abs_sub.z ) ) ) {
                    if( ter( ore ) == t_rock_floor && one_in( 10 ) ) {
                        spawn_item( ore, "chunk_sulfur" );
                    }
                }
            }
            break;
 
            case 3: {
                // Wrecked equipment
                point wreck_location( rng( 9, 14 ), rng( 9, 14 ) );
                for( int i = wreck_location.x - 3; i < wreck_location.x + 3; i++ ) {
                    for( int j = wreck_location.y - 3; j < wreck_location.y + 3; j++ ) {
                        if( !one_in( 4 ) ) {
                            make_rubble( tripoint( i, j, abs_sub.z ), f_wreckage );
                        }
                    }
                }
            }
            break;
 
            case 4: {
                // Dead miners
                const int num_bodies = rng( 4, 8 );
                for( int i = 0; i < num_bodies; i++ ) {
                    if( const auto body = random_point( *this, [this]( const tripoint & p ) {
                    return move_cost( p ) == 2;
                    } ) ) {
                        add_item( *body, item::make_corpse() );
                        place_items( item_group_id( "mon_zombie_miner_death_drops" ), 100, *body, *body,
                                     false, calendar::start_of_cataclysm );
                    }
                }
            }
            break;
 
        }
 
        if( terrain_type == "mine_down" ) { // Don't forget to build a slope down!
            std::vector<direction> open;
            if( dat.n_fac == 4 ) {
                open.push_back( direction::NORTH );
            }
            if( dat.e_fac == 4 ) {
                open.push_back( direction::EAST );
            }
            if( dat.s_fac == 4 ) {
                open.push_back( direction::SOUTH );
            }
            if( dat.w_fac == 4 ) {
                open.push_back( direction::WEST );
            }
 
            if( open.empty() ) { // We'll have to build it in the center
                int tries = 0;
                point p;
                bool okay = true;
                do {
                    p.x = rng( SEEX - 6, SEEX + 1 );
                    p.y = rng( SEEY - 6, SEEY + 1 );
                    okay = true;
                    for( int i = p.x; ( i <= p.x + 5 ) && okay; i++ ) {
                        for( int j = p.y; ( j <= p.y + 5 ) && okay; j++ ) {
                            if( ter( point( i, j ) ) != t_rock_floor ) {
                                okay = false;
                            }
                        }
                    }
                    if( !okay ) {
                        tries++;
                    }
                } while( !okay && tries < 10 );
                if( tries == 10 ) { // Clear the area around the slope down
                    square( this, t_rock_floor, p, p + point( 5, 5 ) );
                }
                // NOLINTNEXTLINE(cata-use-named-point-constants)
                square( this, t_slope_down, p + point( 1, 1 ), p + point( 2, 2 ) );
            } else { // We can build against a wall
                switch( random_entry( open ) ) {
                    case direction::NORTH:
                        square( this, t_rock_floor, point( SEEX - 3, 6 ), point( SEEX + 2, SEEY ) );
                        line( this, t_slope_down, point( SEEX - 2, 6 ), point( SEEX + 1, 6 ) );
                        break;
                    case direction::EAST:
                        square( this, t_rock_floor, point( SEEX + 1, SEEY - 3 ), point( SEEX * 2 - 7, SEEY + 2 ) );
                        line( this, t_slope_down, point( SEEX * 2 - 7, SEEY - 2 ), point( SEEX * 2 - 7, SEEY + 1 ) );
                        break;
                    case direction::SOUTH:
                        square( this, t_rock_floor, point( SEEX - 3, SEEY + 1 ), point( SEEX + 2, SEEY * 2 - 7 ) );
                        line( this, t_slope_down, point( SEEX - 2, SEEY * 2 - 7 ), point( SEEX + 1, SEEY * 2 - 7 ) );
                        break;
                    case direction::WEST:
                        square( this, t_rock_floor, point( 6, SEEY - 3 ), point( SEEX, SEEY + 2 ) );
                        line( this, t_slope_down, point( 6, SEEY - 2 ), point( 6, SEEY + 1 ) );
                        break;
                    default:
                        break;
                }
            }
        } // Done building a slope down
 
        if( dat.above() == "mine_down" ) { // Don't forget to build a slope up!
            std::vector<direction> open;
            if( dat.n_fac == 6 && ter( point( SEEX, 6 ) ) != t_slope_down ) {
                open.push_back( direction::NORTH );
            }
            if( dat.e_fac == 6 && ter( point( SEEX * 2 - 7, SEEY ) ) != t_slope_down ) {
                open.push_back( direction::EAST );
            }
            if( dat.s_fac == 6 && ter( point( SEEX, SEEY * 2 - 7 ) ) != t_slope_down ) {
                open.push_back( direction::SOUTH );
            }
            if( dat.w_fac == 6 && ter( point( 6, SEEY ) ) != t_slope_down ) {
                open.push_back( direction::WEST );
            }
 
            if( open.empty() ) { // We'll have to build it in the center
                int tries = 0;
                point p;
                bool okay = true;
                do {
                    p.x = rng( SEEX - 6, SEEX + 1 );
                    p.y = rng( SEEY - 6, SEEY + 1 );
                    okay = true;
                    for( int i = p.x; ( i <= p.x + 5 ) && okay; i++ ) {
                        for( int j = p.y; ( j <= p.y + 5 ) && okay; j++ ) {
                            if( ter( point( i, j ) ) != t_rock_floor ) {
                                okay = false;
                            }
                        }
                    }
                    if( !okay ) {
                        tries++;
                    }
                } while( !okay && tries < 10 );
                if( tries == 10 ) { // Clear the area around the slope down
                    square( this, t_rock_floor, p, p + point( 5, 5 ) );
                }
                // NOLINTNEXTLINE(cata-use-named-point-constants)
                square( this, t_slope_up, p + point( 1, 1 ), p + point( 2, 2 ) );
 
            } else { // We can build against a wall
                switch( random_entry( open ) ) {
                    case direction::NORTH:
                        line( this, t_slope_up, point( SEEX - 2, 6 ), point( SEEX + 1, 6 ) );
                        break;
                    case direction::EAST:
                        line( this, t_slope_up, point( SEEX * 2 - 7, SEEY - 2 ), point( SEEX * 2 - 7, SEEY + 1 ) );
                        break;
                    case direction::SOUTH:
                        line( this, t_slope_up, point( SEEX - 2, SEEY * 2 - 7 ), point( SEEX + 1, SEEY * 2 - 7 ) );
                        break;
                    case direction::WEST:
                        line( this, t_slope_up, point( 6, SEEY - 2 ), point( 6, SEEY + 1 ) );
                        break;
                    default:
                        break;
                }
            }
        } // Done building a slope up
    } else if( terrain_type == "mine_finale" ) {
        // Set up the basic chamber
        for( int i = 0; i < SEEX * 2; i++ ) {
            for( int j = 0; j < SEEY * 2; j++ ) {
                if( i > rng( 1, 3 ) && i < SEEX * 2 - rng( 2, 4 ) &&
                    j > rng( 1, 3 ) && j < SEEY * 2 - rng( 2, 4 ) ) {
                    ter_set( point( i, j ), t_rock_floor );
                } else {
                    ter_set( point( i, j ), t_rock );
                }
            }
        }
 
        // Now draw the entrance(s)
        if( dat.north() == "mine" ) {
            square( this, t_rock_floor, point( SEEX, 0 ), point( SEEX + 1, 3 ) );
        }
 
        if( dat.east() == "mine" ) {
            square( this, t_rock_floor, point( SEEX * 2 - 4, SEEY ), point( EAST_EDGE, SEEY + 1 ) );
        }
 
        if( dat.south() == "mine" ) {
            square( this, t_rock_floor, point( SEEX, SEEY * 2 - 4 ), point( SEEX + 1, SOUTH_EDGE ) );
        }
 
        if( dat.west() == "mine" ) {
            square( this, t_rock_floor, point( 0, SEEY ), point( 3, SEEY + 1 ) );
        }
 
        // Now, pick and generate a type of finale!
        // The Thing dog
        const int num_bodies = rng( 4, 8 );
        for( int i = 0; i < num_bodies; i++ ) {
            point p3( rng( 4, SEEX * 2 - 5 ), rng( 4, SEEX * 2 - 5 ) );
            add_item( p3, item::make_corpse() );
            place_items( item_group_id( "mon_zombie_miner_death_drops" ), 60, p3,
                         p3, false, calendar::start_of_cataclysm );
        }
        place_spawns( GROUP_DOG_THING, 1, point( SEEX, SEEX ), point( SEEX + 1, SEEX + 1 ), 1, true, true );
        spawn_artifact( tripoint( rng( SEEX, SEEX + 1 ), rng( SEEY, SEEY + 1 ), abs_sub.z ) );
    }
}

References mapgendata::above(), abs_sub, add_field(), add_item(), mapgendata::e_fac, EAST, mapgendata::east(), EAST_EDGE, f_wreckage, fd_gas_vent, GROUP_DOG_THING, is_ot_match(), line(), item::make_corpse(), make_rubble(), move_cost(), mapgendata::n_fac, NORTH, mapgendata::north(), num, one_in(), open(), place_items(), place_spawns(), points_in_rectangle(), prefix, random_entry(), random_point(), rng(), mapgendata::s_fac, SEEX, SEEY, SOUTH, mapgendata::south(), SOUTH_EDGE, spawn_artifact(), spawn_item(), square(), calendar::start_of_cataclysm, t_lava, t_rock, t_rock_floor, t_slope_down, t_slope_up, ter(), ter_set(), mapgendata::terrain_type(), mapgendata::w_fac, WEST, mapgendata::west(), point::x, point::y, and tripoint::z.

Referenced by draw_map().

◆ draw_office_tower()

void map::draw_office_tower ( mapgendata & dat )

protected

Definition at line 2965 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    const auto place_office_chairs = [&]() {
        int num_chairs = rng( 0, 6 );
        for( int i = 0; i < num_chairs; i++ ) {
            add_vehicle( vproto_id( "swivel_chair" ), point( rng( 6, 16 ), rng( 6, 16 ) ),
                         0_degrees, -1, -1, false );
        }
    };
 
    const auto ter_key = mapf::ter_bind( "E > < R # X G C , _ r V H 6 x % ^ . - | "
                                         "t + = D w T S e o h c d l s", t_elevator, t_stairs_down,
                                         t_stairs_up, t_railing, t_rock, t_door_metal_locked,
                                         t_door_glass_c, t_floor, t_pavement_y, t_pavement,
                                         t_floor, t_wall_glass, t_wall_glass, t_console,
                                         t_console_broken, t_shrub, t_floor, t_floor, t_wall,
                                         t_wall, t_floor, t_door_c, t_door_locked,
                                         t_door_locked_alarm, t_window, t_floor, t_floor, t_floor,
                                         t_floor, t_floor, t_floor, t_floor, t_floor, t_sidewalk );
    const auto fur_key = mapf::furn_bind( "E > < R # X G C , _ r V H 6 x % ^ . - | "
                                          "t + = D w T S e o h c d l s", f_null, f_null, f_null,
                                          f_null, f_null, f_null, f_null, f_crate_c, f_null,
                                          f_null, f_rack, f_null, f_null, f_null, f_null, f_null,
                                          f_indoor_plant, f_null, f_null, f_null, f_table, f_null,
                                          f_null, f_null, f_null, f_toilet, f_sink, f_fridge,
                                          f_bookcase, f_chair, f_counter, f_desk,  f_locker,
                                          f_null );
    const auto b_ter_key = mapf::ter_bind( "E s > < R # X G C , . r V H 6 x % ^ _ - | "
                                           "t + = D w T S e o h c d l", t_elevator, t_rock,
                                           t_stairs_down, t_stairs_up, t_railing, t_floor,
                                           t_door_metal_locked, t_door_glass_c, t_floor,
                                           t_pavement_y, t_pavement, t_floor, t_wall_glass,
                                           t_wall_glass, t_console, t_console_broken, t_shrub,
                                           t_floor, t_floor, t_wall, t_wall, t_floor, t_door_c,
                                           t_door_locked, t_door_locked_alarm, t_window, t_floor,
                                           t_sidewalk, t_floor, t_floor, t_floor, t_floor,
                                           t_floor, t_floor );
    const auto b_fur_key = mapf::furn_bind( "E s > < R # X G C , . r V H 6 x % ^ _ - | "
                                            "t + = D w T S e o h c d l", f_null, f_null, f_null,
                                            f_null, f_null, f_bench, f_null, f_null, f_crate_c,
                                            f_null, f_null, f_rack, f_null, f_null, f_null,
                                            f_null, f_null, f_indoor_plant, f_null, f_null,
                                            f_null, f_table, f_null, f_null, f_null, f_null,
                                            f_toilet, f_null,  f_fridge, f_bookcase, f_chair,
                                            f_counter, f_desk,  f_locker );
 
    if( terrain_type == "office_tower_1_entrance" ) {
        dat.fill_groundcover();
        mapf::formatted_set_simple( this, point_zero,
                                    "ss%|....+...|...|EEED...\n"
                                    "ss%|----|...|...|EEx|...\n"
                                    "ss%Vcdc^|...|-+-|---|...\n"
                                    "ss%Vch..+...............\n"
                                    "ss%V....|...............\n"
                                    "ss%|----|-|-+--ccc--|...\n"
                                    "ss%|..C..C|.....h..r|-+-\n"
                                    "sss=......+..h.....r|...\n"
                                    "ss%|r..CC.|.ddd....r|T.S\n"
                                    "ss%|------|---------|---\n"
                                    "ss%|####################\n"
                                    "ss%|#|------||------|###\n"
                                    "ss%|#|......||......|###\n"
                                    "ss%|||......||......|###\n"
                                    "ss%||x......||......||##\n"
                                    "ss%|||......||......x|##\n"
                                    "ss%|#|......||......||##\n"
                                    "ss%|#|......||......|###\n"
                                    "ss%|#|XXXXXX||XXXXXX|###\n"
                                    "ss%|-|__,,__||__,,__|---\n"
                                    "ss%% x_,,,,_  __,,__  %%\n"
                                    "ss    __,,__  _,,,,_    \n"
                                    "ssssss__,,__ss__,,__ssss\n"
                                    "ssssss______ss______ssss\n", ter_key, fur_key );
        place_items( item_group_id( "office" ), 75, point( 4, 2 ), point( 6, 2 ), false,
                     calendar::start_of_cataclysm );
        place_items( item_group_id( "office" ), 75, point( 19, 6 ), point( 19, 6 ), false,
                     calendar::start_of_cataclysm );
        place_items( item_group_id( "office" ), 75, point( 12, 8 ), point( 14, 8 ), false,
                     calendar::start_of_cataclysm );
        if( dat.monster_density() > 1 ) {
            place_spawns( GROUP_ZOMBIE, 2, point_zero, point( 12, 3 ), dat.monster_density() );
        } else {
            place_spawns( GROUP_PLAIN, 2, point( 15, 1 ), point( 22, 7 ), 1, true );
            place_spawns( GROUP_PLAIN, 2, point( 15, 1 ), point( 22, 7 ), 0.15 );
            place_spawns( GROUP_ZOMBIE_COP, 2, point( 10, 10 ), point( 14, 10 ), 0.1 );
        }
        place_office_chairs();
 
        if( dat.north() == "office_tower_1" && dat.west() == "office_tower_1" ) {
            rotate( 3 );
        } else if( dat.north() == "office_tower_1" && dat.east() == "office_tower_1" ) {
            rotate( 0 );
        } else if( dat.south() == "office_tower_1" && dat.east() == "office_tower_1" ) {
            rotate( 1 );
        } else if( dat.west() == "office_tower_1" && dat.south() == "office_tower_1" ) {
            rotate( 2 );
        }
    } else if( terrain_type == "office_tower_1" ) {
        // Init to grass & dirt;
        dat.fill_groundcover();
        if( ( dat.south() == "office_tower_1_entrance" && dat.east() == "office_tower_1" ) ||
            ( dat.north() == "office_tower_1" && dat.east() == "office_tower_1_entrance" ) ||
            ( dat.west() == "office_tower_1" && dat.north() == "office_tower_1_entrance" ) ||
            ( dat.south() == "office_tower_1" && dat.west() == "office_tower_1_entrance" ) ) {
            mapf::formatted_set_simple( this, point_zero,
                                        " ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "ss                      \n"
                                        "ss%%%%%%%%%%%%%%%%%%%%%%\n"
                                        "ss%|-HH-|-HH-|-HH-|HH|--\n"
                                        "ss%Vdcxl|dxdl|lddx|..|.S\n"
                                        "ss%Vdh..|dh..|..hd|..+..\n"
                                        "ss%|-..-|-..-|-..-|..|--\n"
                                        "ss%V.................|.T\n"
                                        "ss%V.................|..\n"
                                        "ss%|-..-|-..-|-..-|..|--\n"
                                        "ss%V.h..|..hd|..hd|..|..\n"
                                        "ss%Vdxdl|^dxd|.xdd|..G..\n"
                                        "ss%|----|----|----|..G..\n"
                                        "ss%|llll|..htth......|..\n"
                                        "ss%V.................|..\n"
                                        "ss%V.ddd..........|+-|..\n"
                                        "ss%|..hd|.hh.ceocc|.l|..\n"
                                        "ss%|----|---------|--|..\n"
                                        "ss%Vcdcl|...............\n"
                                        "ss%V.h..+...............\n"
                                        "ss%V...^|...|---|---|...\n"
                                        "ss%|----|...|.R>|EEE|...\n"
                                        "ss%|rrrr|...|.R.|EEED...\n", ter_key, fur_key );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( 2, 8 ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point( 5, 7 ), point( 15, 20 ), 0.1 );
            }
            place_items( item_group_id( "office" ), 75, point( 4, 23 ), point( 7, 23 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 4, 19 ), point( 7, 19 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 4, 14 ), point( 7, 14 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 5, 16 ), point( 7, 16 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "fridge" ), 80, point( 14, 17 ), point( 14, 17 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cleaning" ), 75, point( 19, 17 ), point( 20, 17 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 6, 12 ), point( 7, 12 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 12, 11 ), point( 12, 12 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 16, 11 ), point( 17, 12 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 4, 5 ), point( 5, 5 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 11, 5 ), point( 12, 5 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 14, 5 ), point( 16, 5 ), false,
                         calendar::start_of_cataclysm );
            place_office_chairs();
 
            if( dat.west() == "office_tower_1_entrance" ) {
                rotate( 1 );
            }
            if( dat.north() == "office_tower_1_entrance" ) {
                rotate( 2 );
            }
            if( dat.east() == "office_tower_1_entrance" ) {
                rotate( 3 );
            }
        } else if( ( dat.west() == "office_tower_1_entrance" && dat.north() == "office_tower_1" ) ||
                   ( dat.north() == "office_tower_1_entrance" && dat.east() == "office_tower_1" ) ||
                   ( dat.west() == "office_tower_1" && dat.south() == "office_tower_1_entrance" ) ||
                   ( dat.south() == "office_tower_1" && dat.east() == "office_tower_1_entrance" ) ) {
            mapf::formatted_set_simple( this, point_zero,
                                        "...DEEE|...|..|-----|%ss\n"
                                        "...|EEE|...|..|^...lV%ss\n"
                                        "...|---|-+-|......hdV%ss\n"
                                        "...........G..|..dddV%ss\n"
                                        "...........G..|-----|%ss\n"
                                        ".......|---|..|...ddV%ss\n"
                                        "|+-|...|...+......hdV%ss\n"
                                        "|.l|...|rr.|.^|l...dV%ss\n"
                                        "|--|...|---|--|-----|%ss\n"
                                        "|...........c.......V%ss\n"
                                        "|.......cxh.c.#####.Vsss\n"
                                        "|.......ccccc.......Gsss\n"
                                        "|...................Gsss\n"
                                        "|...................Vsss\n"
                                        "|#..................Gsss\n"
                                        "|#..................Gsss\n"
                                        "|#..................Vsss\n"
                                        "|#............#####.V%ss\n"
                                        "|...................|%ss\n"
                                        "--HHHHHGGHHGGHHHHH--|%ss\n"
                                        "%%%%% ssssssss %%%%%%%ss\n"
                                        "      ssssssss        ss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n", ter_key, fur_key );
            place_items( item_group_id( "office" ), 75, point( 19, 1 ), point( 19, 3 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 17, 3 ), point( 18, 3 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 90, point( 8, 7 ), point( 9, 7 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 19, 5 ), point( 19, 7 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cleaning" ), 80, point( 1, 7 ), point( 2, 7 ), false,
                         calendar::start_of_cataclysm );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( 14, 10 ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point( 10, 10 ), point( 14, 10 ), 0.15 );
                place_spawns( GROUP_ZOMBIE_COP, 2, point( 10, 10 ), point( 14, 10 ), 0.1 );
            }
            place_office_chairs();
 
            if( dat.north() == "office_tower_1_entrance" ) {
                rotate( 1 );
            }
            if( dat.east() == "office_tower_1_entrance" ) {
                rotate( 2 );
            }
            if( dat.south() == "office_tower_1_entrance" ) {
                rotate( 3 );
            }
        } else {
            mapf::formatted_set_simple( this, point_zero,
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "                      ss\n"
                                        "%%%%%%%%%%%%%%%%%%%%%%ss\n"
                                        "--|---|--HHHH-HHHH--|%ss\n"
                                        ".T|..l|............^|%ss\n"
                                        "..|-+-|...hhhhhhh...V%ss\n"
                                        "--|...G...ttttttt...V%ss\n"
                                        ".S|...G...ttttttt...V%ss\n"
                                        "..+...|...hhhhhhh...V%ss\n"
                                        "--|...|.............|%ss\n"
                                        "..|...|-------------|%ss\n"
                                        "..G....|l.......dxd^|%ss\n"
                                        "..G....G...h....dh..V%ss\n"
                                        "..|....|............V%ss\n"
                                        "..|....|------|llccc|%ss\n"
                                        "..|...........|-----|%ss\n"
                                        "..|...........|...ddV%ss\n"
                                        "..|----|---|......hdV%ss\n"
                                        ".......+...|..|l...dV%ss\n"
                                        ".......|rrr|..|-----|%ss\n"
                                        "...|---|---|..|l.dddV%ss\n"
                                        "...|xEE|.R>|......hdV%ss\n"
                                        "...DEEE|.R.|..|.....V%ss\n", ter_key, fur_key );
            spawn_item( point( 18, 15 ), "record_accounting" );
            place_items( item_group_id( "cleaning" ), 75, point( 3, 5 ), point( 5, 5 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 10, 7 ), point( 16, 8 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 15, 15 ), point( 19, 15 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 16, 12 ), point( 16, 13 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cubical_office" ), 75, point( 17, 19 ), point( 19, 19 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 17, 21 ), point( 19, 21 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "office" ), 75, point( 16, 11 ), point( 17, 12 ), false,
                         calendar::start_of_cataclysm );
            place_items( item_group_id( "cleaning" ), 75, point( 8, 20 ), point( 10, 20 ), false,
                         calendar::start_of_cataclysm );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( 9, 15 ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point_zero, point( 9, 15 ), 0.1 );
            }
            place_office_chairs();
 
            if( dat.west() == "office_tower_1" && dat.north() == "office_tower_1" ) {
                rotate( 1 );
            } else if( dat.east() == "office_tower_1" && dat.north() == "office_tower_1" ) {
                rotate( 2 );
            } else if( dat.east() == "office_tower_1" && dat.south() == "office_tower_1" ) {
                rotate( 3 );
            }
        }
    } else if( terrain_type == "office_tower_b_entrance" ) {
        dat.fill_groundcover();
        mapf::formatted_set_simple( this, point_zero,
                                    "sss|........|...|EEED___\n"
                                    "sss|........|...|EEx|___\n"
                                    "sss|........|-+-|---|HHG\n"
                                    "sss|....................\n"
                                    "sss|....................\n"
                                    "sss|....................\n"
                                    "sss|....................\n"
                                    "sss|....,,......,,......\n"
                                    "sss|...,,,,.....,,......\n"
                                    "sss|....,,.....,,,,..xS.\n"
                                    "sss|....,,......,,...SS.\n"
                                    "sss|-|XXXXXX||XXXXXX|---\n"
                                    "sss|s|EEEEEE||EEEEEE|sss\n"
                                    "sss|||EEEEEE||EEEEEE|sss\n"
                                    "sss||xEEEEEE||EEEEEE||ss\n"
                                    "sss|||EEEEEE||EEEEEEx|ss\n"
                                    "sss|s|EEEEEE||EEEEEE||ss\n"
                                    "sss|s|EEEEEE||EEEEEE|sss\n"
                                    "sss|s|------||------|sss\n"
                                    "sss|--------------------\n"
                                    "ssssssssssssssssssssssss\n"
                                    "ssssssssssssssssssssssss\n"
                                    "ssssssssssssssssssssssss\n"
                                    "ssssssssssssssssssssssss\n", ter_key, fur_key );
        if( dat.monster_density() > 1 ) {
            place_spawns( GROUP_ZOMBIE, 2, point_zero, point( EAST_EDGE, SOUTH_EDGE ), dat.monster_density() );
        } else {
            place_spawns( GROUP_PLAIN, 1, point_zero, point( EAST_EDGE, SOUTH_EDGE ), 0.1 );
        }
        if( dat.north() == "office_tower_b" && dat.west() == "office_tower_b" ) {
            rotate( 3 );
        } else if( dat.north() == "office_tower_b" && dat.east() == "office_tower_b" ) {
            rotate( 0 );
        } else if( dat.south() == "office_tower_b" && dat.east() == "office_tower_b" ) {
            rotate( 1 );
        } else if( dat.west() == "office_tower_b" && dat.south() == "office_tower_b" ) {
            rotate( 2 );
        }
    } else if( terrain_type == "office_tower_b" ) {
        // Init to grass & dirt;
        dat.fill_groundcover();
        if( ( dat.south() == "office_tower_b_entrance" && dat.east() == "office_tower_b" ) ||
            ( dat.north() == "office_tower_b" && dat.east() == "office_tower_b_entrance" ) ||
            ( dat.west() == "office_tower_b" && dat.north() == "office_tower_b_entrance" ) ||
            ( dat.south() == "office_tower_b" && dat.west() == "office_tower_b_entrance" ) ) {
            mapf::formatted_set_simple( this, point_zero,
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "sss|--------------------\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|,.....,.....,.....,S\n"
                                        "sss|....................\n"
                                        "sss|....................\n"
                                        "sss|....................\n"
                                        "sss|....................\n"
                                        "sss|....................\n"
                                        "sss|....................\n"
                                        "sss|...,,...,....,....,S\n"
                                        "sss|..,,,,..,....,....,S\n"
                                        "sss|...,,...,....,....,S\n"
                                        "sss|...,,...,....,....,S\n"
                                        "sss|........,....,....,S\n"
                                        "sss|........,....,....,S\n"
                                        "sss|........|---|---|HHG\n"
                                        "sss|........|.R<|EEE|___\n"
                                        "sss|........|.R.|EEED___\n", b_ter_key, b_fur_key );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( EAST_EDGE, SOUTH_EDGE ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point_zero, point( EAST_EDGE, SOUTH_EDGE ), 0.1 );
            }
            if( dat.west() == "office_tower_b_entrance" ) {
                rotate( 1 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 17, 7 ), 180_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "motorcycle" ), point( 17, 13 ), 180_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "fire_truck" ), point( 6, 13 ), 0_degrees );
                    } else {
                        add_vehicle( vproto_id( "pickup" ), point( 17, 19 ), 180_degrees );
                    }
                }
            } else if( dat.north() == "office_tower_b_entrance" ) {
                rotate( 2 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 10, 17 ), 270_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "motorcycle" ), point( 4, 18 ), 270_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "fire_truck" ), point( 6, 13 ), 0_degrees );
                    } else {
                        add_vehicle( vproto_id( "pickup" ), point( 16, 17 ), 270_degrees );
                    }
                }
            } else if( dat.east() == "office_tower_b_entrance" ) {
                rotate( 3 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 6, 4 ), 0_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "motorcycle" ), point( 6, 10 ), 180_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 6, 16 ), 0_degrees );
                }
 
            } else {
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 7, 6 ), 90_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 14, 6 ), 90_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "motorcycle" ), point( 19, 6 ), 90_degrees );
                }
            }
        } else if( ( dat.west() == "office_tower_b_entrance" && dat.north() == "office_tower_b" ) ||
                   ( dat.north() == "office_tower_b_entrance" && dat.east() == "office_tower_b" ) ||
                   ( dat.west() == "office_tower_b" && dat.south() == "office_tower_b_entrance" ) ||
                   ( dat.south() == "office_tower_b" && dat.east() == "office_tower_b_entrance" ) ) {
            mapf::formatted_set_simple( this, point_zero,
                                        "___DEEE|...|...,,...|sss\n"
                                        "___|EEE|...|..,,,,..|sss\n"
                                        "GHH|---|-+-|...,,...|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "|...................|sss\n"
                                        "|...................|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|,.....,.....,.....,|sss\n"
                                        "|-------------------|sss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n", b_ter_key, b_fur_key );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( EAST_EDGE, SOUTH_EDGE ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point_zero, point( EAST_EDGE, SOUTH_EDGE ), 0.1 );
            }
            if( dat.north() == "office_tower_b_entrance" ) {
                rotate( 1 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 8, 15 ), 0_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 7, 10 ), 180_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "beetle" ), point( 7, 3 ), 0_degrees );
                }
            } else if( dat.east() == "office_tower_b_entrance" ) {
                rotate( 2 );
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "fire_truck" ), point( 6, 13 ), 0_degrees );
                    } else {
                        add_vehicle( vproto_id( "pickup" ), point( 7, 7 ), 270_degrees );
                    }
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 13, 8 ), 90_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "beetle" ), point( 20, 7 ), 90_degrees );
                }
            } else if( dat.south() == "office_tower_b_entrance" ) {
                rotate( 3 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 16, 7 ), 0_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 15, 13 ), 180_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "beetle" ), point( 15, 20 ), 180_degrees );
                }
            } else {
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 16, 16 ), 90_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 9, 15 ), 270_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "beetle" ), point( 4, 16 ), 270_degrees );
                }
            }
        } else {
            mapf::formatted_set_simple( this, point_zero,
                                        "ssssssssssssssssssssssss\n"
                                        "ssssssssssssssssssssssss\n"
                                        "--------------------|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "S,.....,.....,.....,|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "....................|sss\n"
                                        "S,....,....,........|sss\n"
                                        "S,....,....,........|sss\n"
                                        "S,....,....,........|sss\n"
                                        "S,....,....,........|sss\n"
                                        "S,....,....,........|sss\n"
                                        "S,....,....,........|sss\n"
                                        "GHH|---|---|........|sss\n"
                                        "___|xEE|.R<|........|sss\n"
                                        "___DEEE|.R.|...,,...|sss\n", b_ter_key, b_fur_key );
            if( dat.monster_density() > 1 ) {
                place_spawns( GROUP_ZOMBIE, 2, point_zero, point( EAST_EDGE, SOUTH_EDGE ), dat.monster_density() );
            } else {
                place_spawns( GROUP_PLAIN, 1, point_zero, point( EAST_EDGE, SOUTH_EDGE ), 0.1 );
            }
            if( dat.west() == "office_tower_b" && dat.north() == "office_tower_b" ) {
                rotate( 1 );
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "cube_van" ), point( 17, 4 ), 180_degrees );
                    } else {
                        add_vehicle( vproto_id( "cube_van_cheap" ), point( 17, 4 ), 180_degrees );
                    }
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 17, 10 ), 180_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 17, 17 ), 180_degrees );
                }
            } else if( dat.east() == "office_tower_b" && dat.north() == "office_tower_b" ) {
                rotate( 2 );
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "cube_van" ), point( 6, 17 ), 270_degrees );
                    } else {
                        add_vehicle( vproto_id( "cube_van_cheap" ), point( 6, 17 ), 270_degrees );
                    }
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "pickup" ), point( 12, 17 ), 270_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "fire_truck" ), point( 18, 17 ), 270_degrees );
                }
            } else if( dat.east() == "office_tower_b" && dat.south() == "office_tower_b" ) {
                rotate( 3 );
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "cube_van_cheap" ), point( 6, 6 ), 0_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    if( one_in( 3 ) ) {
                        add_vehicle( vproto_id( "fire_truck" ), point( 6, 13 ), 0_degrees );
                    } else {
                        add_vehicle( vproto_id( "pickup" ), point( 6, 13 ), 0_degrees );
                    }
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 5, 19 ), 180_degrees );
                }
            } else {
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "flatbed_truck" ), point( 16, 6 ), 90_degrees );
                }
                if( x_in_y( 1, 5 ) ) {
                    add_vehicle( vproto_id( "cube_van_cheap" ), point( 10, 6 ), 90_degrees );
                }
                if( x_in_y( 1, 3 ) ) {
                    add_vehicle( vproto_id( "car" ), point( 4, 6 ), 90_degrees );
                }
            }
        }
    }
}

References add_vehicle(), mapgendata::east(), EAST_EDGE, f_bench, f_bookcase, f_chair, f_counter, f_crate_c, f_desk, f_fridge, f_indoor_plant, f_locker, f_null, f_rack, f_sink, f_table, f_toilet, mapgendata::fill_groundcover(), mapf::formatted_set_simple(), mapf::furn_bind(), GROUP_PLAIN, GROUP_ZOMBIE, GROUP_ZOMBIE_COP, mapgendata::monster_density(), mapgendata::north(), one_in(), place_items(), place_spawns(), point_zero, rng(), rotate(), mapgendata::south(), SOUTH_EDGE, spawn_item(), calendar::start_of_cataclysm, t_console, t_console_broken, t_door_c, t_door_glass_c, t_door_locked, t_door_locked_alarm, t_door_metal_locked, t_elevator, t_floor, t_pavement, t_pavement_y, t_railing, t_rock, t_shrub, t_sidewalk, t_stairs_down, t_stairs_up, t_wall, t_wall_glass, t_window, mapf::ter_bind(), mapgendata::terrain_type(), mapgendata::west(), and x_in_y().

Referenced by draw_map().

◆ draw_rough_circle_furn()

void map::draw_rough_circle_furn	(	const furn_id &	type,
		point	p,
		int	rad
	)

Definition at line 8575 of file map.cpp.

{
    draw_rough_circle( [this, type]( point  q ) {
        this->furn_set( q, type );
    }, p, rad );
}

References draw_rough_circle(), furn_set(), rad, and type.

Referenced by rough_circle_furn().

◆ draw_rough_circle_ter()

void map::draw_rough_circle_ter	(	const ter_id &	type,
		point	p,
		int	rad
	)

Definition at line 8568 of file map.cpp.

{
    draw_rough_circle( [this, type]( point  q ) {
        this->ter_set( q, type );
    }, p, rad );
}

References draw_rough_circle(), rad, ter_set(), and type.

Referenced by rough_circle().

◆ draw_slimepit()

void map::draw_slimepit ( mapgendata & dat )

protected

Definition at line 4882 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( is_ot_match( "slimepit", terrain_type, ot_match_type::prefix ) ) {
        for( int i = 0; i < SEEX * 2; i++ ) {
            for( int j = 0; j < SEEY * 2; j++ ) {
                if( !one_in( 10 ) && ( j < dat.n_fac * SEEX ||
                                       i < dat.w_fac * SEEX ||
                                       j > SEEY * 2 - dat.s_fac * SEEY ||
                                       i > SEEX * 2 - dat.e_fac * SEEX ) ) {
                    ter_set( point( i, j ), ( !one_in( 10 ) ? t_slime : t_rock_floor ) );
                } else if( rng( 0, SEEX ) > std::abs( i - SEEX ) && rng( 0, SEEY ) > std::abs( j - SEEY ) ) {
                    ter_set( point( i, j ), t_slime );
                } else if( dat.zlevel() == 0 ) {
                    ter_set( point( i, j ), t_dirt );
                } else {
                    ter_set( point( i, j ), t_rock_floor );
                }
            }
        }
        if( terrain_type == "slimepit_down" ) {
            ter_set( point( rng( 3, SEEX * 2 - 4 ), rng( 3, SEEY * 2 - 4 ) ), t_slope_down );
        }
        if( dat.above() == "slimepit_down" ) {
            switch( rng( 1, 4 ) ) {
                case 1:
                    ter_set( point( rng( 0, 2 ), rng( 0, 2 ) ), t_slope_up );
                    break;
                case 2:
                    ter_set( point( rng( 0, 2 ), SEEY * 2 - rng( 1, 3 ) ), t_slope_up );
                    break;
                case 3:
                    ter_set( point( SEEX * 2 - rng( 1, 3 ), rng( 0, 2 ) ), t_slope_up );
                    break;
                case 4:
                    ter_set( point( SEEX * 2 - rng( 1, 3 ), SEEY * 2 - rng( 1, 3 ) ), t_slope_up );
            }
        }
        place_spawns( GROUP_BLOB, 1, point( SEEX, SEEY ), point( SEEX, SEEY ), 0.15 );
        place_items( item_group_id( "sewer" ), 40, point_zero, point( EAST_EDGE, SOUTH_EDGE ), true,
                     calendar::start_of_cataclysm );
    }
}

References mapgendata::above(), mapgendata::e_fac, EAST_EDGE, GROUP_BLOB, is_ot_match(), mapgendata::n_fac, one_in(), place_items(), place_spawns(), point_zero, prefix, rng(), mapgendata::s_fac, SEEX, SEEY, SOUTH_EDGE, calendar::start_of_cataclysm, t_dirt, t_rock_floor, t_slime, t_slope_down, t_slope_up, ter_set(), mapgendata::terrain_type(), mapgendata::w_fac, and mapgendata::zlevel().

Referenced by draw_map().

◆ draw_square_furn()

void map::draw_square_furn	(	const furn_id &	type,
		point	p1,
		point	p2
	)

Definition at line 8545 of file map.cpp.

{
    draw_square( [this, type]( point  p ) {
        this->furn_set( p, type );
    }, p1, p2 );
}

References draw_square(), furn_set(), and type.

Referenced by jmapgen_setmap::apply(), mission_start::ranch_nurse_1(), mission_start::ranch_nurse_2(), mission_start::ranch_nurse_7(), mission_start::ranch_nurse_8(), and square_furn().

◆ draw_square_ter() [1/3]

void map::draw_square_ter	(	const ter_id &	type,
		point	p1,
		point	p2
	)

Definition at line 8538 of file map.cpp.

{
    draw_square( [this, type]( point  p ) {
        this->ter_set( p, type );
    }, p1, p2 );
}

References draw_square(), ter_set(), and type.

Referenced by jmapgen_setmap::apply(), draw_fill_background(), talk_function::field_build_1(), talk_function::field_build_2(), talk_function::field_plant(), mission_start::ranch_nurse_3(), mission_start::ranch_nurse_4(), mission_start::ranch_nurse_5(), mission_start::ranch_nurse_6(), mission_start::ranch_nurse_7(), mission_start::ranch_scavenger_1(), mission_start::ranch_scavenger_2(), mission_start::ranch_scavenger_3(), square(), and mapgendata::square_groundcover().

◆ draw_square_ter() [2/3]

void map::draw_square_ter	(	const weighted_int_list< ter_id > &	f,
		point	p1,
		point	p2
	)

Definition at line 8559 of file map.cpp.

{
    draw_square( [this, f]( point  p ) {
        const ter_id *tid = f.pick();
        this->ter_set( p, tid != nullptr ? *tid : t_null );
    }, p1, p2 );
}

References draw_square(), weighted_list< W, T >::pick(), t_null, and ter_set().

◆ draw_square_ter() [3/3]

void map::draw_square_ter	(	ter_id(*)()	f,
		point	p1,
		point	p2
	)

Definition at line 8552 of file map.cpp.

{
    draw_square( [this, f]( point  p ) {
        this->ter_set( p, f() );
    }, p1, p2 );
}

References draw_square(), and ter_set().

◆ draw_temple()

void map::draw_temple ( mapgendata & dat )

protected

Definition at line 4350 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( terrain_type == "temple" || terrain_type == "temple_stairs" ) {
        if( dat.zlevel() == 0 ) {
            // Ground floor
            // TODO: More varieties?
            fill_background( this, t_dirt );
            square( this, t_grate, point( SEEX - 1, SEEY - 1 ), point( SEEX, SEEX ) );
            ter_set( point( SEEX + 1, SEEY + 1 ), t_pedestal_temple );
        } else {
            // Underground!  Shit's about to get interesting!
            // Start with all rock floor
            square( this, t_rock_floor, point_zero, point( EAST_EDGE, SOUTH_EDGE ) );
            // We always start at the south and go north.
            // We use (y / 2 + z) % 4 to guarantee that rooms don't repeat.
            switch( 1 + std::abs( abs_sub.y / 2 + dat.zlevel() + 4 ) % 4 ) { // TODO: More varieties!
 
                case 1:
                    // Flame bursts
                    square( this, t_rock, point_zero, point( SEEX - 1, SOUTH_EDGE ) );
                    square( this, t_rock, point( SEEX + 2, 0 ), point( EAST_EDGE, SOUTH_EDGE ) );
                    for( int i = 2; i < SEEY * 2 - 4; i++ ) {
                        add_field( {SEEX, i, abs_sub.z}, fd_fire_vent, rng( 1, 3 ) );
                        add_field( {SEEX + 1, i, abs_sub.z}, fd_fire_vent, rng( 1, 3 ) );
                    }
                    break;
 
                case 2:
                    // Spreading water
                    square( this, t_water_dp, point( 4, 4 ), point( 5, 5 ) );
                    // replaced mon_sewer_snake spawn with GROUP_SEWER
                    // Decide whether a group of only sewer snakes be made, probably not worth it
                    place_spawns( GROUP_SEWER, 1, point( 4, 4 ), point( 4, 4 ), 1, true );
 
                    square( this, t_water_dp, point( SEEX * 2 - 5, 4 ), point( SEEX * 2 - 4, 6 ) );
                    place_spawns( GROUP_SEWER, 1, point( 1, SEEX * 2 - 5 ), point( 1, SEEX * 2 - 5 ), 1, true );
 
                    square( this, t_water_dp, point( 4, SEEY * 2 - 5 ), point( 6, SEEY * 2 - 4 ) );
 
                    square( this, t_water_dp, point( SEEX * 2 - 5, SEEY * 2 - 5 ), point( SEEX * 2 - 4,
                            SEEY * 2 - 4 ) );
 
                    square( this, t_rock, point( 0, SEEY * 2 - 2 ), point( SEEX - 1, SOUTH_EDGE ) );
                    square( this, t_rock, point( SEEX + 2, SEEY * 2 - 2 ), point( EAST_EDGE, SOUTH_EDGE ) );
                    line( this, t_grate, point( SEEX, 1 ), point( SEEX + 1, 1 ) ); // To drain the water
                    mtrap_set( this, point( SEEX, SEEY * 2 - 2 ), tr_temple_flood );
                    mtrap_set( this, point( SEEX + 1, SEEY * 2 - 2 ), tr_temple_flood );
                    for( int y = 2; y < SEEY * 2 - 2; y++ ) {
                        for( int x = 2; x < SEEX * 2 - 2; x++ ) {
                            if( ter( point( x, y ) ) == t_rock_floor && one_in( 4 ) ) {
                                mtrap_set( this, point( x, y ), tr_temple_flood );
                            }
                        }
                    }
                    break;
 
                case 3: { // Flipping walls puzzle
                    line( this, t_rock, point_zero, point( SEEX - 1, 0 ) );
                    line( this, t_rock, point( SEEX + 2, 0 ), point( EAST_EDGE, 0 ) );
                    line( this, t_rock, point( SEEX - 1, 1 ), point( SEEX - 1, 6 ) );
                    line( this, t_bars, point( SEEX + 2, 1 ), point( SEEX + 2, 6 ) );
                    ter_set( point( 14, 1 ), t_switch_rg );
                    ter_set( point( 15, 1 ), t_switch_gb );
                    ter_set( point( 16, 1 ), t_switch_rb );
                    ter_set( point( 17, 1 ), t_switch_even );
                    // Start with clear floors--then work backwards to the starting state
                    line( this, t_floor_red,   point( SEEX, 1 ), point( SEEX + 1, 1 ) );
                    line( this, t_floor_green, point( SEEX, 2 ), point( SEEX + 1, 2 ) );
                    line( this, t_floor_blue,  point( SEEX, 3 ), point( SEEX + 1, 3 ) );
                    line( this, t_floor_red,   point( SEEX, 4 ), point( SEEX + 1, 4 ) );
                    line( this, t_floor_green, point( SEEX, 5 ), point( SEEX + 1, 5 ) );
                    line( this, t_floor_blue,  point( SEEX, 6 ), point( SEEX + 1, 6 ) );
                    // Now, randomly choose actions
                    // Set up an actions vector so that there's not undue repetition
                    std::vector<int> actions;
                    actions.push_back( 1 );
                    actions.push_back( 2 );
                    actions.push_back( 3 );
                    actions.push_back( 4 );
                    actions.push_back( rng( 1, 3 ) );
                    while( !actions.empty() ) {
                        const int action = random_entry_removed( actions );
                        for( int y = 1; y < 7; y++ ) {
                            for( int x = SEEX; x <= SEEX + 1; x++ ) {
                                switch( action ) {
                                    case 1:
                                        // Toggle RG
                                        if( ter( point( x, y ) ) == t_floor_red ) {
                                            ter_set( point( x, y ), t_rock_red );
                                        } else if( ter( point( x, y ) ) == t_rock_red ) {
                                            ter_set( point( x, y ), t_floor_red );
                                        } else if( ter( point( x, y ) ) == t_floor_green ) {
                                            ter_set( point( x, y ), t_rock_green );
                                        } else if( ter( point( x, y ) ) == t_rock_green ) {
                                            ter_set( point( x, y ), t_floor_green );
                                        }
                                        break;
                                    case 2:
                                        // Toggle GB
                                        if( ter( point( x, y ) ) == t_floor_blue ) {
                                            ter_set( point( x, y ), t_rock_blue );
                                        } else if( ter( point( x, y ) ) == t_rock_blue ) {
                                            ter_set( point( x, y ), t_floor_blue );
                                        } else if( ter( point( x, y ) ) == t_floor_green ) {
                                            ter_set( point( x, y ), t_rock_green );
                                        } else if( ter( point( x, y ) ) == t_rock_green ) {
                                            ter_set( point( x, y ), t_floor_green );
                                        }
                                        break;
                                    case 3:
                                        // Toggle RB
                                        if( ter( point( x, y ) ) == t_floor_blue ) {
                                            ter_set( point( x, y ), t_rock_blue );
                                        } else if( ter( point( x, y ) ) == t_rock_blue ) {
                                            ter_set( point( x, y ), t_floor_blue );
                                        } else if( ter( point( x, y ) ) == t_floor_red ) {
                                            ter_set( point( x, y ), t_rock_red );
                                        } else if( ter( point( x, y ) ) == t_rock_red ) {
                                            ter_set( point( x, y ), t_floor_red );
                                        }
                                        break;
                                    case 4:
                                        // Toggle Even
                                        if( y % 2 == 0 ) {
                                            if( ter( point( x, y ) ) == t_floor_blue ) {
                                                ter_set( point( x, y ), t_rock_blue );
                                            } else if( ter( point( x, y ) ) == t_rock_blue ) {
                                                ter_set( point( x, y ), t_floor_blue );
                                            } else if( ter( point( x, y ) ) == t_floor_red ) {
                                                ter_set( point( x, y ), t_rock_red );
                                            } else if( ter( point( x, y ) ) == t_rock_red ) {
                                                ter_set( point( x, y ), t_floor_red );
                                            } else if( ter( point( x, y ) ) == t_floor_green ) {
                                                ter_set( point( x, y ), t_rock_green );
                                            } else if( ter( point( x, y ) ) == t_rock_green ) {
                                                ter_set( point( x, y ), t_floor_green );
                                            }
                                        }
                                        break;
                                }
                            }
                        }
                    }
                }
                break;
 
                case 4: { // Toggling walls maze
                    square( this, t_rock, point_zero, point( SEEX     - 1, 1 ) );
                    square( this, t_rock, point( 0, SEEY * 2 - 2 ), point( SEEX     - 1, SOUTH_EDGE ) );
                    square( this, t_rock, point( 0, 2 ), point( SEEX     - 4, SEEY * 2 - 3 ) );
                    square( this, t_rock, point( SEEX + 2, 0 ), point( EAST_EDGE, 1 ) );
                    square( this, t_rock, point( SEEX + 2, SEEY * 2 - 2 ), point( EAST_EDGE, SOUTH_EDGE ) );
                    square( this, t_rock, point( SEEX + 5, 2 ), point( EAST_EDGE, SEEY * 2 - 3 ) );
                    int x = rng( SEEX - 1, SEEX + 2 ), y = 2;
                    std::vector<point> path; // Path, from end to start
                    while( x < SEEX - 1 || x > SEEX + 2 || y < SEEY * 2 - 2 ) {
                        static const std::vector<ter_id> terrains = {
                            t_floor_red, t_floor_green, t_floor_blue,
                        };
                        path.push_back( point( x, y ) );
                        ter_set( point( x, y ), random_entry( terrains ) );
                        if( y == SEEY * 2 - 2 ) {
                            if( x < SEEX - 1 ) {
                                x++;
                            } else if( x > SEEX + 2 ) {
                                x--;
                            }
                        } else {
                            std::vector<point> next;
                            for( int nx = x - 1; nx <= x + 1; nx++ ) {
                                for( int ny = y; ny <= y + 1; ny++ ) {
                                    if( ter( point( nx, ny ) ) == t_rock_floor ) {
                                        next.push_back( point( nx, ny ) );
                                    }
                                }
                            }
                            if( next.empty() ) {
                                break;
                            } else {
                                const point p = random_entry( next );
                                x = p.x;
                                y = p.y;
                            }
                        }
                    }
                    // Now go backwards through path (start to finish), toggling any tiles that need
                    bool toggle_red = false;
                    bool toggle_green = false;
                    bool toggle_blue = false;
                    for( int i = path.size() - 1; i >= 0; i-- ) {
                        if( ter( path[i] ) == t_floor_red ) {
                            toggle_green = !toggle_green;
                            if( toggle_red ) {
                                ter_set( path[i], t_rock_red );
                            }
                        } else if( ter( path[i] ) == t_floor_green ) {
                            toggle_blue = !toggle_blue;
                            if( toggle_green ) {
                                ter_set( path[i], t_rock_green );
                            }
                        } else if( ter( path[i] ) == t_floor_blue ) {
                            toggle_red = !toggle_red;
                            if( toggle_blue ) {
                                ter_set( path[i], t_rock_blue );
                            }
                        }
                    }
                    // Finally, fill in the rest with random tiles, and place toggle traps
                    for( int i = SEEX - 3; i <= SEEX + 4; i++ ) {
                        for( int j = 2; j <= SEEY * 2 - 2; j++ ) {
                            mtrap_set( this, point( i, j ), tr_temple_toggle );
                            if( ter( point( i, j ) ) == t_rock_floor ) {
                                static const std::vector<ter_id> terrains = {
                                    t_rock_red, t_rock_green, t_rock_blue,
                                    t_floor_red, t_floor_green, t_floor_blue,
                                };
                                ter_set( point( i, j ), random_entry( terrains ) );
                            }
                        }
                    }
                }
                break;
            } // Done with room type switch
            // Stairs down if we need them
            if( terrain_type == "temple_stairs" ) {
                line( this, t_stairs_down, point( SEEX, 0 ), point( SEEX + 1, 0 ) );
            }
            // Stairs at the south if dat.above() has stairs down.
            if( dat.above() == "temple_stairs" ) {
                line( this, t_stairs_up, point( SEEX, SOUTH_EDGE ), point( SEEX + 1, SOUTH_EDGE ) );
            }
 
        } // Done with underground-only stuff
    } else if( terrain_type == "temple_finale" ) {
        fill_background( this, t_rock );
        square( this, t_rock_floor, point( SEEX - 1, 1 ), point( SEEX + 2, 4 ) );
        square( this, t_rock_floor, point( SEEX, 5 ), point( SEEX + 1, SOUTH_EDGE ) );
        line( this, t_stairs_up, point( SEEX, SOUTH_EDGE ), point( SEEX + 1, SOUTH_EDGE ) );
        spawn_artifact( tripoint( rng( SEEX, SEEX + 1 ), rng( 2, 3 ), abs_sub.z ) );
        spawn_artifact( tripoint( rng( SEEX, SEEX + 1 ), rng( 2, 3 ), abs_sub.z ) );
        return;
 
    }
}

References mapgendata::above(), abs_sub, action, add_field(), EAST_EDGE, fd_fire_vent, fill_background(), GROUP_SEWER, line(), mtrap_set(), one_in(), place_spawns(), point_zero, random_entry(), random_entry_removed(), rng(), SEEX, SEEY, SOUTH_EDGE, spawn_artifact(), square(), t_bars, t_dirt, t_floor_blue, t_floor_green, t_floor_red, t_grate, t_pedestal_temple, t_rock, t_rock_blue, t_rock_floor, t_rock_green, t_rock_red, t_stairs_down, t_stairs_up, t_switch_even, t_switch_gb, t_switch_rb, t_switch_rg, t_water_dp, ter(), ter_set(), mapgendata::terrain_type(), anonymous_namespace{overmap.cpp}::terrains, tr_temple_flood, tr_temple_toggle, point::x, point::y, tripoint::y, tripoint::z, and mapgendata::zlevel().

Referenced by draw_map().

◆ draw_triffid()

void map::draw_triffid ( mapgendata & dat )

protected

Definition at line 4926 of file mapgen.cpp.

{
    const oter_id &terrain_type = dat.terrain_type();
    if( terrain_type == "triffid_roots" ) {
        fill_background( this, t_root_wall );
        int node = 0;
        int step = 0;
        bool node_built[16];
        bool done = false;
        for( auto &elem : node_built ) {
            elem = false;
        }
        do {
            node_built[node] = true;
            step++;
            point node2( 1 + 6 * ( node % 4 ), 1 + 6 * static_cast<int>( node / 4 ) );
            // Clear a 4x4 dirt square
            square( this, t_dirt, node2, node2 + point( 3, 3 ) );
            // Spawn a monster in there
            if( step > 2 ) { // First couple of chambers are safe
                int monrng = rng( 1, 25 );
                point spawn( node2 + point{ rng( 0, 3 ), rng( 0, 3 ) } );
                if( monrng <= 24 ) {
                    place_spawns( GROUP_TRIFFID_OUTER, 1, node2,
                                  node2 + point( 3, 3 ), 1, true );
                } else {
                    for( int webx = node2.x; webx <= node2.x + 3; webx++ ) {
                        for( int weby = node2.y; weby <= node2.y + 3; weby++ ) {
                            add_field( {webx, weby, abs_sub.z}, fd_web, rng( 1, 3 ) );
                        }
                    }
                    place_spawns( GROUP_SPIDER, 1, spawn, spawn, 1, true );
                }
            }
            // TODO: Non-monster hazards?
            // Next, pick a cell to move to
            std::vector<direction> move;
            if( node % 4 > 0 && !node_built[node - 1] ) {
                move.push_back( direction::WEST );
            }
            if( node % 4 < 3 && !node_built[node + 1] ) {
                move.push_back( direction::EAST );
            }
            if( static_cast<int>( node / 4 ) > 0 && !node_built[node - 4] ) {
                move.push_back( direction::NORTH );
            }
            if( static_cast<int>( node / 4 ) < 3 && !node_built[node + 4] ) {
                move.push_back( direction::SOUTH );
            }
 
            if( move.empty() ) { // Nowhere to go!
                square( this, t_slope_down, node2 + point_south_east, node2 + point( 2, 2 ) );
                done = true;
            } else {
                switch( random_entry( move ) ) {
                    case direction::NORTH:
                        square( this, t_dirt, node2 + point( 1, -2 ), node2 + point( 2, -1 ) );
                        node -= 4;
                        break;
                    case direction::EAST:
                        square( this, t_dirt, node2 + point( 4, 1 ), node2 + point( 5, 2 ) );
                        node++;
                        break;
                    case direction::SOUTH:
                        square( this, t_dirt, node2 + point( 1, 4 ), node2 + point( 2, 5 ) );
                        node += 4;
                        break;
                    case direction::WEST:
                        square( this, t_dirt, node2 + point( -2, 1 ), node2 + point( -1, 2 ) );
                        node--;
                        break;
                    default:
                        break;
                }
            }
        } while( !done );
        square( this, t_slope_up, point( 2, 2 ), point( 3, 3 ) );
        rotate( rng( 0, 3 ) );
    } else if( terrain_type == "triffid_finale" ) {
        fill_background( this, t_root_wall );
        // NOLINTNEXTLINE(cata-use-named-point-constants)
        square( this, t_dirt, point( 1, 1 ), point( 4, 4 ) );
        square( this, t_dirt, point( 19, 19 ), point( 22, 22 ) );
        // Drunken walk until we reach the heart (lower right, [19, 19])
        // Chance increases by 1 each turn, and gives the % chance of forcing a move
        // to the right or down.
        int chance = 0;
        int x = 4;
        int y = 4;
        do {
            ter_set( point( x, y ), t_dirt );
 
            if( chance >= 10 && one_in( 10 ) ) { // Add a spawn
                place_spawns( GROUP_TRIFFID, 1, point( x, y ), point( x, y ), 1, true );
            }
 
            if( rng( 0, 99 ) < chance ) { // Force movement down or to the right
                if( x >= 19 ) {
                    y++;
                } else if( y >= 19 ) {
                    x++;
                } else {
                    if( one_in( 2 ) ) {
                        x++;
                    } else {
                        y++;
                    }
                }
            } else {
                chance++; // Increase chance of forced movement down/right
                // Weigh movement towards directions with lots of existing walls
                int chance_west = 0;
                int chance_east = 0;
                int chance_north = 0;
                int chance_south = 0;
                for( int dist = 1; dist <= 5; dist++ ) {
                    if( ter( point( x - dist, y ) ) == t_root_wall ) {
                        chance_west++;
                    }
                    if( ter( point( x + dist, y ) ) == t_root_wall ) {
                        chance_east++;
                    }
                    if( ter( point( x, y - dist ) ) == t_root_wall ) {
                        chance_north++;
                    }
                    if( ter( point( x, y + dist ) ) == t_root_wall ) {
                        chance_south++;
                    }
                }
                int roll = rng( 0, chance_west + chance_east + chance_north + chance_south );
                if( roll < chance_west && x > 0 ) {
                    x--;
                } else if( roll < chance_west + chance_east && x < EAST_EDGE ) {
                    x++;
                } else if( roll < chance_west + chance_east + chance_north && y > 0 ) {
                    y--;
                } else if( y < SOUTH_EDGE ) {
                    y++;
                }
            } // Done with drunken walk
        } while( x < 19 || y < 19 );
        // NOLINTNEXTLINE(cata-use-named-point-constants)
        square( this, t_slope_up, point( 1, 1 ), point( 2, 2 ) );
        place_spawns( GROUP_TRIFFID_HEART, 1, point( 21, 21 ), point( 21, 21 ), 1, true );
 
    }
}

References abs_sub, add_field(), detail::digits::done, EAST, EAST_EDGE, fd_web, fill_background(), GROUP_SPIDER, GROUP_TRIFFID, GROUP_TRIFFID_HEART, GROUP_TRIFFID_OUTER, avatar_action::move(), NORTH, one_in(), place_spawns(), point_south_east, random_entry(), rng(), rotate(), SOUTH, SOUTH_EDGE, square(), t_dirt, t_root_wall, t_slope_down, t_slope_up, ter(), ter_set(), mapgendata::terrain_type(), WEST, point::x, point::y, and tripoint::z.

Referenced by draw_map().

◆ drawsq()

void map::drawsq	(	const catacurses::window &	w,
		const tripoint &	p,
		const drawsq_params &	params
	)		const

Draw the map tile at the given coordinate.

Called by map::draw().

Parameters

w	The window we are drawing in
p	The tile on this map to draw.
params	Draw parameters.

Definition at line 5968 of file map.cpp.

{
    // If we are in tiles mode, the only thing we want to potentially draw is a highlight
    if( is_draw_tiles_mode() ) {
        if( params.highlight() ) {
            g->draw_highlight( p );
        }
        return;
    }
 
    if( !inbounds( p ) ) {
        return;
    }
 
    const tripoint view_center = params.center();
    const int k = p.x + getmaxx( w ) / 2 - view_center.x;
    const int j = p.y + getmaxy( w ) / 2 - view_center.y;
    wmove( w, point( k, j ) );
 
    const maptile tile = maptile_at( p );
    if( draw_maptile( w, p, tile, params ) ) {
        return;
    }
 
    tripoint below( p.xy(), p.z - 1 );
    const maptile tile_below = maptile_at( below );
    draw_from_above( w, below, tile_below, params );
}

References drawsq_params::center(), draw_from_above(), draw_maptile(), g, catacurses::getmaxx(), catacurses::getmaxy(), drawsq_params::highlight(), inbounds(), is_draw_tiles_mode(), maptile_at(), catacurses::wmove(), tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by anonymous_namespace{animation.cpp}::draw_line_curses(), game::draw_look_around_cursor(), editmap::draw_main_ui_overlay(), target_ui::draw_terrain_overlay(), game::pickup(), and editmap::uber_draw_ter().

◆ drop_everything()

void map::drop_everything ( const tripoint & p )

Handles map objects of given type (not creatures) falling down.

Returns true if anything changed.

Definition at line 2127 of file map.cpp.

{
    //Do a suspension check so that there won't be a floor there for the rest of this check.
    if( has_flag( "SUSPENDED", p ) ) {
        collapse_invalid_suspension( p );
    }
    if( has_floor( p ) ) {
        return;
    }
 
    drop_furniture( p );
    drop_items( p );
    drop_vehicle( p );
    drop_fields( p );
}

References collapse_invalid_suspension(), drop_fields(), drop_furniture(), drop_items(), drop_vehicle(), has_flag(), and has_floor().

Referenced by process_falling().

◆ drop_fields()

void map::drop_fields ( const tripoint & p )

Definition at line 2325 of file map.cpp.

{
    field &fld = field_at( p );
    if( fld.field_count() == 0 ) {
        return;
    }
 
    std::list<field_type_id> dropped;
    const tripoint below = p + tripoint_below;
    for( const auto &iter : fld ) {
        const field_entry &entry = iter.second;
        // For now only drop cosmetic fields, which don't warrant per-turn check
        // Active fields "drop themselves"
        if( entry.decays_on_actualize() ) {
            add_field( below, entry.get_field_type(), entry.get_field_intensity(), entry.get_field_age() );
            dropped.push_back( entry.get_field_type() );
        }
    }
 
    for( const auto &entry : dropped ) {
        fld.remove_field( entry );
    }
}

References add_field(), field_entry::decays_on_actualize(), field_at(), field::field_count(), field_entry::get_field_age(), field_entry::get_field_intensity(), field_entry::get_field_type(), field::remove_field(), and tripoint_below.

Referenced by drop_everything().

◆ drop_furniture()

void map::drop_furniture ( const tripoint & p )

Definition at line 2143 of file map.cpp.

{
    const furn_id frn = furn( p );
    if( frn == f_null ) {
        return;
    }
 
    enum support_state {
        SS_NO_SUPPORT = 0,
        SS_BAD_SUPPORT, // TODO: Implement bad, shaky support
        SS_GOOD_SUPPORT,
        SS_FLOOR, // Like good support, but bash floor instead of tile below
        SS_CREATURE
    };
 
    // Checks if the tile:
    // has floor (supports unconditionally)
    // has support below
    // has unsupporting furniture below (bad support, things should "slide" if possible)
    // has no support and thus allows things to fall through
    const auto check_tile = [this]( const tripoint & pt ) {
        if( has_floor( pt ) ) {
            return SS_FLOOR;
        }
 
        tripoint below_dest( pt.xy(), pt.z - 1 );
        if( supports_above( below_dest ) ) {
            return SS_GOOD_SUPPORT;
        }
 
        const furn_id frn_id = furn( below_dest );
        if( frn_id != f_null ) {
            const furn_t &frn = frn_id.obj();
            // Allow crushing tiny/nocollide furniture
            if( !frn.has_flag( "TINY" ) && !frn.has_flag( "NOCOLLIDE" ) ) {
                return SS_BAD_SUPPORT;
            }
        }
 
        if( g->critter_at( below_dest ) != nullptr ) {
            // Smash a critter
            return SS_CREATURE;
        }
 
        return SS_NO_SUPPORT;
    };
 
    tripoint current( p.xy(), p.z + 1 );
    support_state last_state = SS_NO_SUPPORT;
    while( last_state == SS_NO_SUPPORT ) {
        current.z--;
        // Check current tile
        last_state = check_tile( current );
    }
 
    if( current == p ) {
        // Nothing happened
        if( last_state != SS_FLOOR ) {
            support_dirty( current );
        }
 
        return;
    }
 
    furn_set( p, f_null );
    furn_set( current, frn );
 
    // If it's sealed, we need to drop items with it
    const auto &frn_obj = frn.obj();
    if( frn_obj.has_flag( TFLAG_SEALED ) && has_items( p ) ) {
        auto old_items = i_at( p );
        auto new_items = i_at( current );
        for( const auto &it : old_items ) {
            new_items.insert( it );
        }
 
        i_clear( p );
    }
 
    // Approximate weight/"bulkiness" based on strength to drag
    int weight;
    if( frn_obj.has_flag( "TINY" ) || frn_obj.has_flag( "NOCOLLIDE" ) ) {
        weight = 5;
    } else {
        weight = frn_obj.is_movable() ? frn_obj.move_str_req : 20;
    }
 
    if( frn_obj.has_flag( "ROUGH" ) || frn_obj.has_flag( "SHARP" ) ) {
        weight += 5;
    }
 
    // TODO: Balance this.
    int dmg = weight * ( p.z - current.z );
 
    if( last_state == SS_FLOOR ) {
        // Bash the same tile twice - once for furniture, once for the floor
        bash( current, dmg, false, false, true );
        bash( current, dmg, false, false, true );
    } else if( last_state == SS_BAD_SUPPORT || last_state == SS_GOOD_SUPPORT ) {
        bash( current, dmg, false, false, false );
        tripoint below( current.xy(), current.z - 1 );
        bash( below, dmg, false, false, false );
    } else if( last_state == SS_CREATURE ) {
        const std::string &furn_name = frn_obj.name();
        bash( current, dmg, false, false, false );
        tripoint below( current.xy(), current.z - 1 );
        Creature *critter = g->critter_at( below );
        if( critter == nullptr ) {
            debugmsg( "drop_furniture couldn't find creature at %d,%d,%d",
                      below.x, below.y, below.z );
            return;
        }
 
        critter->add_msg_player_or_npc( m_bad, _( "Falling %s hits you!" ),
                                        _( "Falling %s hits <npcname>" ),
                                        furn_name );
        // TODO: A chance to dodge/uncanny dodge
        player *pl = dynamic_cast<player *>( critter );
        monster *mon = dynamic_cast<monster *>( critter );
        if( pl != nullptr ) {
            pl->deal_damage( nullptr, bodypart_id( "torso" ), damage_instance( DT_BASH, rng( dmg / 3, dmg ), 0,
                             0.5f ) );
            pl->deal_damage( nullptr, bodypart_id( "head" ),  damage_instance( DT_BASH, rng( dmg / 3, dmg ), 0,
                             0.5f ) );
            pl->deal_damage( nullptr, bodypart_id( "leg_l" ), damage_instance( DT_BASH, rng( dmg / 2, dmg ), 0,
                             0.4f ) );
            pl->deal_damage( nullptr, bodypart_id( "leg_r" ), damage_instance( DT_BASH, rng( dmg / 2, dmg ), 0,
                             0.4f ) );
            pl->deal_damage( nullptr, bodypart_id( "arm_l" ), damage_instance( DT_BASH, rng( dmg / 2, dmg ), 0,
                             0.4f ) );
            pl->deal_damage( nullptr, bodypart_id( "arm_r" ), damage_instance( DT_BASH, rng( dmg / 2, dmg ), 0,
                             0.4f ) );
        } else if( mon != nullptr ) {
            // TODO: Monster's armor and size - don't crush hulks with chairs
            mon->apply_damage( nullptr, bodypart_id( "torso" ), rng( dmg, dmg * 2 ) );
        }
    }
 
    // Re-queue for another check, in case bash destroyed something
    support_dirty( current );
}

References _, Creature::add_msg_player_or_npc(), monster::apply_damage(), bash(), Character::deal_damage(), debugmsg, DT_BASH, f_null, furn(), furn_set(), g, map_data_common_t::has_flag(), has_floor(), has_items(), i_at(), i_clear(), m_bad, int_id< T >::obj(), rng(), support_dirty(), supports_above(), TFLAG_SEALED, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by drop_everything().

◆ drop_items()

void map::drop_items ( const tripoint & p )

Definition at line 2285 of file map.cpp.

{
    if( !has_items( p ) ) {
        return;
    }
 
    auto items = i_at( p );
    // TODO: Make items check the volume tile below can accept
    // rather than disappearing if it would be overloaded
 
    tripoint below( p );
    while( !has_floor( below ) ) {
        below.z--;
    }
 
    if( below == p ) {
        return;
    }
 
    for( const auto &i : items ) {
        // TODO: Bash the item up before adding it
        // TODO: Bash the creature, terrain, furniture and vehicles on the tile
        add_item_or_charges( below, i );
    }
 
    // Just to make a sound for now
    bash( below, 1 );
    i_clear( p );
}

References add_item_or_charges(), bash(), has_floor(), has_items(), i_at(), i_clear(), and tripoint::z.

Referenced by drop_everything().

◆ drop_vehicle()

void map::drop_vehicle ( const tripoint & p )

Definition at line 2315 of file map.cpp.

{
    const optional_vpart_position vp = veh_at( p );
    if( !vp ) {
        return;
    }
 
    vp->vehicle().is_falling = true;
}

References veh_at().

Referenced by drop_everything().

◆ emit_field()

void map::emit_field	(	const tripoint &	pos,
		const emit_id &	src,
		float	mul = `1.0f`
	)

Runs one cycle of emission src which may result in propagation of fields.

Parameters

pos	Location of emission
src	Id of object producing the emission
mul	Multiplies the chance and possibly qty (if `chance*mul > 100`) of the emission

Definition at line 1928 of file map_field.cpp.

{
    if( !src.is_valid() ) {
        return;
    }
 
    const float chance = src->chance() * mul;
    if( src.is_valid() &&  x_in_y( chance, 100 ) ) {
        const int qty = chance > 100.0f ? roll_remainder( src->qty() * chance / 100.0f ) : src->qty();
        propagate_field( pos, src->field(), qty, src->intensity() );
    }
}

References emit::chance(), emit::field(), emit::intensity(), string_id< T >::is_valid(), propagate_field(), emit::qty(), roll_remainder(), and x_in_y().

Referenced by enchantment::activate_passive(), and game::do_turn().

◆ examine()

void map::examine	(	Character &	p,
		const tripoint &	pos
	)

Calls the examine function of furniture or terrain at given tile, for given character.

Examines the tile pos, with character as the "examinator" Casts Character to player because player/NPC split isn't done yet.

Will only examine terrain if furniture had iexamine::none as the examine function.

Definition at line 1685 of file map.cpp.

{
    const auto furn_here = furn( pos ).obj();
    if( furn_here.examine != iexamine::none ) {
        furn_here.examine( dynamic_cast<player &>( p ), pos );
    } else {
        ter( pos ).obj().examine( dynamic_cast<player &>( p ), pos );
    }
}

References map_data_common_t::examine, furn(), iexamine::none(), int_id< T >::obj(), wrapped_vehicle::pos, and ter().

Referenced by water_from().

◆ features() [1/2]

std::string map::features ( const tripoint & p )

Definition at line 1779 of file map.cpp.

{
    std::string result;
    const auto add = [&]( const std::string & text ) {
        if( !result.empty() ) {
            result += " ";
        }
        result += text;
    };
    const auto add_if = [&]( const bool cond, const std::string & text ) {
        if( cond ) {
            add( text );
        }
    };
    // This is used in an info window that is 46 characters wide, and is expected
    // to take up one line.  So, make sure it does that.
    // FIXME: can't control length of localized text.
    add_if( is_bashable( p ), _( "Smashable." ) );
    add_if( has_flag( "DIGGABLE", p ), _( "Diggable." ) );
    add_if( has_flag( "PLOWABLE", p ), _( "Plowable." ) );
    add_if( has_flag( "ROUGH", p ), _( "Rough." ) );
    add_if( has_flag( "UNSTABLE", p ), _( "Unstable." ) );
    add_if( has_flag( "SHARP", p ), _( "Sharp." ) );
    add_if( has_flag( "FLAT", p ), _( "Flat." ) );
    add_if( has_flag( "EASY_DECONSTRUCT", p ), _( "Simple." ) );
    add_if( has_flag( "MOUNTABLE", p ), _( "Mountable." ) );
    return result;
}

References _, om_direction::add(), has_flag(), and is_bashable().

Referenced by features(), and game::print_terrain_info().

◆ features() [2/2]

std::string map::features ( point p )

inline

Definition at line 899 of file map.h.

                                      {
            return features( tripoint( p, abs_sub.z ) );
        }

References abs_sub, features(), and tripoint::z.

◆ field_at() [1/2]

field & map::field_at ( const tripoint & p )

Gets fields that are here.

Both for querying and edition.

Definition at line 5436 of file map.cpp.

{
    if( !inbounds( p ) ) {
        nulfield = field();
        return nulfield;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_field( l );
}

References field, submap::get_field(), get_submap_at(), inbounds(), and nulfield.

◆ field_at() [2/2]

const field & map::field_at ( const tripoint & p ) const

Get the fields that are here.

This is for querying and looking at it only, one can not change the fields.

Parameters

p	The local map coordinates, if out of bounds, returns an empty field.

Definition at line 5420 of file map.cpp.

{
    if( !inbounds( p ) ) {
        nulfield = field();
        return nulfield;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_field( l );
}

References field, submap::get_field(), get_submap_at(), inbounds(), and nulfield.

Referenced by dangerous_field_at(), decay_cosmetic_fields(), editmap::draw_main_ui_overlay(), drop_fields(), game::get_dangerous_tile(), get_field(), get_field_age(), get_field_intensity(), mop_spills(), game::print_fields_info(), process_fields_in_submap(), and Character::symbol_color().

◆ fill_funnels()

void map::fill_funnels	(	const tripoint &	p,
		const time_point &	since
	)

protected

Try to fill funnel based items here.

Simulates rain from since till now.

Parameters

p	The location in this map where to fill funnels.

Definition at line 7269 of file map.cpp.

{
    const auto &tr = tr_at( p );
    if( !tr.is_funnel() ) {
        return;
    }
    // Note: the inside/outside cache might not be correct at this time
    if( has_flag_ter_or_furn( TFLAG_INDOORS, p ) ) {
        return;
    }
    auto items = i_at( p );
    units::volume maxvolume = 0_ml;
    auto biggest_container = items.end();
    for( auto candidate = items.begin(); candidate != items.end(); ++candidate ) {
        if( candidate->is_funnel_container( maxvolume ) ) {
            biggest_container = candidate;
        }
    }
    if( biggest_container != items.end() ) {
        retroactively_fill_from_funnel( *biggest_container, tr, since, calendar::turn, getabs( p ) );
    }
}

References getabs(), has_flag_ter_or_furn(), i_at(), retroactively_fill_from_funnel(), TFLAG_INDOORS, tr_at(), and calendar::turn.

Referenced by actualize().

◆ find_clear_path()

std::vector< tripoint > map::find_clear_path	(	const tripoint &	source,
		const tripoint &	destination
	)		const

Iteratively tries Bresenham lines with different biases until it finds a clear line or decides there isn't one.

returns the line found, which may be the straight line, but blocked.

Definition at line 6402 of file map.cpp.

{
    // TODO: Push this junk down into the Bresenham method, it's already doing it.
    const point d( destination.xy() - source.xy() );
    const point a( std::abs( d.x ) * 2, std::abs( d.y ) * 2 );
    const int dominant = std::max( a.x, a.y );
    const int minor = std::min( a.x, a.y );
    // This seems to be the method for finding the ideal start value for the error value.
    const int ideal_start_offset = minor - dominant / 2;
    const int start_sign = ( ideal_start_offset > 0 ) - ( ideal_start_offset < 0 );
    // Not totally sure of the derivation.
    const int max_start_offset = std::abs( ideal_start_offset ) * 2 + 1;
    for( int horizontal_offset = -1; horizontal_offset <= max_start_offset; ++horizontal_offset ) {
        int candidate_offset = horizontal_offset * start_sign;
        if( sees( source, destination, rl_dist( source, destination ), candidate_offset ) ) {
            return line_to( source, destination, candidate_offset, 0 );
        }
    }
    // If we couldn't find a clear LoS, just return the ideal one.
    return line_to( source, destination, ideal_start_offset, 0 );
}

References a, line_to(), minor, rl_dist(), sees(), point::x, tripoint::xy(), and point::y.

◆ find_furnitures_or_vparts_with_flag_in_radius()

std::list< tripoint > map::find_furnitures_or_vparts_with_flag_in_radius	(	const tripoint &	center,
		size_t	radius,
		const std::string &	flag,
		size_t	radiusz = `0`
	)

returns positions of furnitures or vehicle parts with matching flag in the specified radius

Definition at line 8848 of file map.cpp.

{
    std::list<tripoint> locs;
    for( const auto &loc : points_in_radius( center, radius, radiusz ) ) {
        // workaround for ramp bridges
        int dz = 0;
        if( has_flag( TFLAG_RAMP_UP, loc ) ) {
            dz = 1;
        } else if( has_flag( TFLAG_RAMP_DOWN, loc ) ) {
            dz = -1;
        }
 
        if( dz == 0 ) {
            if( has_flag_furn_or_vpart( flag, loc ) ) {
                locs.push_back( loc );
            }
        } else {
            const tripoint newloc( loc + tripoint( 0, 0, dz ) );
            if( has_flag_furn_or_vpart( flag, newloc ) ) {
                locs.push_back( newloc );
            }
        }
    }
 
    return locs;
}

References center, has_flag(), has_flag_furn_or_vpart(), points_in_radius(), TFLAG_RAMP_DOWN, and TFLAG_RAMP_UP.

◆ find_furnitures_with_flag_in_radius()

std::list< tripoint > map::find_furnitures_with_flag_in_radius	(	const tripoint &	center,
		size_t	radius,
		const std::string &	flag,
		size_t	radiusz = `0`
	)

returns positions of furnitures with matching flag in the specified radius

Definition at line 8834 of file map.cpp.

{
    std::list<tripoint> furn_locs;
    for( const auto &furn_loc : points_in_radius( center, radius, radiusz ) ) {
        if( has_flag_furn( flag, furn_loc ) ) {
            furn_locs.push_back( furn_loc );
        }
    }
    return furn_locs;
}

References center, has_flag_furn(), and points_in_radius().

◆ flammable_items_at()

bool map::flammable_items_at	(	const tripoint &	p,
		int	threshold = `0`
	)

Checks if there are any flammable items on the tile.

Parameters

p	tile to check
threshold	Fuel threshold (lower means worse fuels are accepted).

Definition at line 2688 of file map.cpp.

{
    if( !has_items( p ) ||
        ( has_flag( TFLAG_SEALED, p ) && !has_flag( TFLAG_ALLOW_FIELD_EFFECT, p ) ) ) {
        // Sealed containers don't allow fire, so shouldn't allow setting the fire either
        return false;
    }
 
    for( const auto &i : i_at( p ) ) {
        if( i.flammable( threshold ) ) {
            return true;
        }
    }
 
    return false;
}

References has_flag(), has_items(), i_at(), TFLAG_ALLOW_FIELD_EFFECT, and TFLAG_SEALED.

Referenced by MapExtras::burned_ground_parser(), is_flammable(), and process_fields_in_submap().

◆ floor_between()

bool map::floor_between	(	const tripoint &	first,
		const tripoint &	second
	)		const

Checks if there's a floor between the two tiles.

They must be at most 1 tile away from each other in any dimension. If they're not at the same xy coord there must be floor on both of the relevant tiles

Definition at line 2085 of file map.cpp.

{
    int diff = std::abs( first.z - second.z );
    if( diff == 0 ) { //There's never a floor between two tiles on the same level
        return false;
    }
    if( diff != 1 ) {
        debugmsg( "map::floor_between should only be called on tiles that are exactly 1 z level apart" );
        return true;
    }
    int upper = std::max( first.z, second.z );
    if( first.xy() == second.xy() ) {
        return has_floor( tripoint( first.xy(), upper ) );
    }
    return has_floor( tripoint( first.xy(), upper ) ) && has_floor( tripoint( second.xy(), upper ) );
}

References debugmsg, has_floor(), second, tripoint::xy(), and tripoint::z.

◆ free_volume()

units::volume map::free_volume ( const tripoint & p )

Definition at line 4350 of file map.cpp.

{
    return i_at( p ).free_volume();
}

References item_stack::free_volume(), and i_at().

Referenced by add_item_or_charges(), and advanced_inv_area::free_volume().

◆ function_over()

template<typename Functor >

void map::function_over	(	const tripoint &	start,
		const tripoint &	end,
		Functor	fun
	)		const

private

Runs a functor over given submaps over submaps in the area, getting next submap only when the current one "runs out" rather than every time.

gp in the functor is Grid (like get_submap_at_grid) coordinate of the submap, Will silently clip the area to map bounds.

Parameters

start	Starting point for function
end	End point for function
fun	Function to run

Definition at line 8648 of file map.cpp.

{
    // start and end are just two points, end can be "before" start
    // Also clip the area to map area
    const tripoint min( std::max( std::min( start.x, end.x ), 0 ), std::max( std::min( start.y, end.y ),
                        0 ), std::max( std::min( start.z, end.z ), -OVERMAP_DEPTH ) );
    const tripoint max( std::min( std::max( start.x, end.x ), SEEX * my_MAPSIZE - 1 ),
                        std::min( std::max( start.y, end.y ), SEEY * my_MAPSIZE - 1 ), std::min( std::max( start.z, end.z ),
                                OVERMAP_HEIGHT ) );
 
    // Submaps that contain the bounding points
    const point min_sm( min.x / SEEX, min.y / SEEY );
    const point max_sm( max.x / SEEX, max.y / SEEY );
    // Z outermost, because submaps are flat
    tripoint gp;
    int &z = gp.z;
    int &smx = gp.x;
    int &smy = gp.y;
    for( z = min.z; z <= max.z; z++ ) {
        for( smx = min_sm.x; smx <= max_sm.x; smx++ ) {
            for( smy = min_sm.y; smy <= max_sm.y; smy++ ) {
                submap const *cur_submap = get_submap_at_grid( { smx, smy, z } );
                // Bounds on the submap coordinates
                const point sm_min( smx > min_sm.x ? 0 : min.x % SEEX, smy > min_sm.y ? 0 : min.y % SEEY );
                const point sm_max( smx < max_sm.x ? SEEX - 1 : max.x % SEEX,
                                    smy < max_sm.y ? SEEY - 1 : max.y % SEEY );
 
                point lp;
                int &sx = lp.x;
                int &sy = lp.y;
                for( sx = sm_min.x; sx <= sm_max.x; ++sx ) {
                    for( sy = sm_min.y; sy <= sm_max.y; ++sy ) {
                        const iteration_state rval = fun( gp, cur_submap, lp );
                        if( rval != ITER_CONTINUE ) {
                            switch( rval ) {
                                case ITER_SKIP_ZLEVEL:
                                    smx = my_MAPSIZE + 1;
                                    smy = my_MAPSIZE + 1;
                                // Fall through
                                case ITER_SKIP_SUBMAP:
                                    sx = SEEX;
                                    sy = SEEY;
                                    break;
                                default:
                                    return;
                            }
                        }
                    }
                }
            }
        }
    }
}

References get_submap_at_grid(), ITER_CONTINUE, ITER_SKIP_SUBMAP, ITER_SKIP_ZLEVEL, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, SEEX, SEEY, sx, sy, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by scent_blockers().

◆ furn() [1/2]

furn_id map::furn ( const tripoint & p ) const

Definition at line 1413 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return f_null;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_furn( l );
}

References f_null, submap::get_furn(), get_submap_at(), and inbounds().

Referenced by actualize(), ter_furn_transform::add_all_messages(), bash_furn_success(), bash_rating(), bash_resistance(), bash_strength(), bash_ter_furn(), board_up(), MapExtras::burned_ground_parser(), can_move_furniture(), close_door(), doors::close_door(), coverage(), create_anomaly(), MapExtras::dead_vegetation_parser(), destroy_furn(), game::do_turn(), draw_lab(), editmap::draw_main_ui_overlay(), drop_furniture(), examine(), game::examine(), game::extended_description(), farm_action(), feature< furn_id >(), talk_function::field_harvest(), find_potential_computer_point(), inventory::form_from_map(), furn(), furn_is_supported(), furnname(), get_changed_ids_from_update(), activity_handlers::repair_activity_hack::anonymous_namespace{activity_handlers.cpp}::get_fake_tool(), get_furn_transforms_into(), get_harvest(), get_harvest_names(), get_keg_capacity(), game::grabbed_furn_move(), grow_plant(), has_adjacent_furniture_with(), has_flag_furn(), has_furn(), is_bashable(), is_bashable_furn(), talk_function::loot_building(), map_stack::max_volume(), avatar_action::move(), move_cost(), obstacle_coverage(), om_harvest_furn(), open_door(), Character::place_corpse(), game::place_player(), mission_start::place_priest_diary(), rad_scorch(), resolve_regional_terrain_and_furniture(), fungal_effects::spread_fungus_one_tile(), ter_furn_transform::transform(), use_charges(), iexamine::use_furn_fake_item(), game::walk_move(), and water_from().

◆ furn() [2/2]

furn_id map::furn ( point p ) const

inline

Definition at line 793 of file map.h.

                                      {
            return furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, furn(), and tripoint::z.

◆ furn_set() [1/2]

void map::furn_set	(	const tripoint &	p,
		const furn_id &	new_furniture,
		cata::poly_serialized< active_tile_data >	new_active = `nullptr`
	)

Sets the furniture at given position.

Parameters

p	Position within the map
new_furniture	Id of new furniture
new_active	Override default active tile of new furniture

Definition at line 1425 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
    const furn_id old_id = current_submap->get_furn( l );
    if( old_id == new_furniture ) {
        // Nothing changed
        return;
    }
 
    current_submap->set_furn( l, new_furniture );
 
    // Set the dirty flags
    const furn_t &old_t = old_id.obj();
    const furn_t &new_t = new_furniture.obj();
 
    // If player has grabbed this furniture and it's no longer grabbable, release the grab.
    if( g->u.get_grab_type() == OBJECT_FURNITURE && g->u.grab_point == p && !new_t.is_movable() ) {
        add_msg( _( "The %s you were grabbing is destroyed!" ), old_t.name() );
        g->u.grab( OBJECT_NONE );
    }
    // If a creature was crushed under a rubble -> free it
    if( old_id == f_rubble && new_furniture == f_null ) {
        Creature *c = g->critter_at( p );
        if( c ) {
            c->remove_effect( effect_crushed );
        }
    }
    if( new_t.has_flag( "EMITTER" ) ) {
        field_furn_locs.push_back( p );
    }
    if( old_t.transparent != new_t.transparent ) {
        set_transparency_cache_dirty( p );
        set_seen_cache_dirty( p );
    }
 
    if( old_t.has_flag( TFLAG_INDOORS ) != new_t.has_flag( TFLAG_INDOORS ) ) {
        set_outside_cache_dirty( p.z );
    }
 
    if( old_t.has_flag( TFLAG_NO_FLOOR ) != new_t.has_flag( TFLAG_NO_FLOOR ) ) {
        set_floor_cache_dirty( p.z );
        set_seen_cache_dirty( p );
    }
 
    if( old_t.has_flag( TFLAG_SUN_ROOF_ABOVE ) != new_t.has_flag( TFLAG_SUN_ROOF_ABOVE ) ) {
        set_floor_cache_dirty( p.z + 1 );
    }
 
    invalidate_max_populated_zlev( p.z );
 
    set_memory_seen_cache_dirty( p );
 
    // TODO: Limit to changes that affect move cost, traps and stairs
    set_pathfinding_cache_dirty( p.z );
 
    // Make sure the furniture falls if it needs to
    support_dirty( p );
    tripoint above( p.xy(), p.z + 1 );
    // Make sure that if we supported something and no longer do so, it falls down
    support_dirty( above );
 
    if( old_t.active ) {
        current_submap->active_furniture.erase( point_sm_ms( l ) );
        // TODO: Only for g->m? Observer pattern?
        get_distribution_grid_tracker().on_changed( tripoint_abs_ms( getabs( p ) ) );
    }
    if( new_t.active || new_active ) {
        cata::poly_serialized<active_tile_data> atd;
        if( new_active ) {
            atd = new_active;
        } else {
            atd = new_t.active->clone();
            atd->set_last_updated( calendar::turn );
        }
        current_submap->active_furniture[point_sm_ms( l )] = atd;
        get_distribution_grid_tracker().on_changed( tripoint_abs_ms( getabs( p ) ) );
    }
}

References _, furn_t::active, submap::active_furniture, add_msg(), c, effect_crushed, f_null, f_rubble, field_furn_locs, g, get_distribution_grid_tracker(), submap::get_furn(), get_submap_at(), getabs(), map_data_common_t::has_flag(), inbounds(), invalidate_max_populated_zlev(), furn_t::is_movable(), map_data_common_t::name(), int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, distribution_grid_tracker::on_changed(), set_floor_cache_dirty(), submap::set_furn(), set_memory_seen_cache_dirty(), set_outside_cache_dirty(), set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_transparency_cache_dirty(), support_dirty(), TFLAG_INDOORS, TFLAG_NO_FLOOR, TFLAG_SUN_ROOF_ABOVE, map_data_common_t::transparent, calendar::turn, tripoint::xy(), and tripoint::z.

Referenced by grid_furn_transform_queue::apply(), jmapgen_sign::apply(), jmapgen_vending_machine::apply(), jmapgen_toilet::apply(), jmapgen_gaspump::apply(), jmapgen_furniture::apply(), jmapgen_terrain::apply(), jmapgen_computer::apply(), jmapgen_sealed_item::apply(), jmapgen_setmap::apply(), bash_furn_success(), board_up(), MapExtras::burned_ground_parser(), close_door(), collapse_at(), collapse_invalid_suspension(), activity_handlers::cracking_finish(), create_anomaly(), MapExtras::dead_vegetation_parser(), draw_circle_furn(), draw_lab(), draw_line_furn(), draw_rough_circle_furn(), draw_square_furn(), drop_furniture(), farm_action(), talk_function::field_harvest(), mapgen_function_json_base::formatted_set_incredibly_simple(), mapf::formatted_set_simple(), furn_set(), game::grabbed_furn_move(), grow_plant(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), talk_function::loot_building(), make_rubble(), mapgen_forest(), mapgen_forest_trail_curved(), mapgen_forest_trail_four_way(), mapgen_forest_trail_straight(), mapgen_forest_trail_tee(), mapgen_lake_shore(), mapgen_tutorial(), MapExtras::mx_burned_ground(), MapExtras::mx_clay_deposit(), MapExtras::mx_grave(), MapExtras::mx_house_spider(), MapExtras::mx_minefield(), MapExtras::mx_pond(), MapExtras::mx_roadworks(), MapExtras::mx_spider(), MapExtras::mx_supplydrop(), om_harvest_furn(), open_door(), iexamine::open_safe(), place_toilet(), place_vending(), process_fields_in_submap(), rad_scorch(), mission_start::ranch_nurse_9(), mission_start::ranch_scavenger_3(), resolve_regional_terrain_and_furniture(), iexamine::safe(), science_room(), set(), fungal_effects::spread_fungus_one_tile(), ter_or_furn_set(), ter_furn_transform::transform(), and game::vertical_move().

◆ furn_set() [2/2]

void map::furn_set	(	point	p,
		const furn_id &	new_furniture
	)

inline

Definition at line 805 of file map.h.

                                                               {
            furn_set( tripoint( p, abs_sub.z ), new_furniture );
        }

References abs_sub, furn_set(), and tripoint::z.

◆ furnname() [1/2]

std::string map::furnname ( const tripoint & p )

Definition at line 1534 of file map.cpp.

{
    const furn_t &f = furn( p ).obj();
    if( f.has_flag( "PLANT" ) ) {
        // Can't use item_stack::only_item() since there might be fertilizer
        map_stack items = i_at( p );
        const map_stack::iterator seed = std::find_if( items.begin(), items.end(), []( const item & it ) {
            return it.is_seed();
        } );
        if( seed == items.end() ) {
            debugmsg( "Missing seed for plant at (%d, %d, %d)", p.x, p.y, p.z );
            return "null";
        }
        const std::string &plant = seed->get_plant_name();
        return string_format( "%s (%s)", f.name(), plant );
    } else {
        return f.name();
    }
}

References item_stack::begin(), debugmsg, item_stack::end(), furn(), map_data_common_t::has_flag(), i_at(), map_data_common_t::name(), int_id< T >::obj(), plant, iuse::seed(), string_format(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by furnname(), name(), and game::place_player().

◆ furnname() [2/2]

std::string map::furnname ( point p )

inline

Definition at line 809 of file map.h.

                                      {
            return furnname( tripoint( p, abs_sub.z ) );
        }

References abs_sub, furnname(), and tripoint::z.

◆ gas_can_spread_to()

bool map::gas_can_spread_to	(	field_entry &	cur,
		const tripoint &	src,
		const tripoint &	dst
	)

private

Definition at line 212 of file map_field.cpp.

{
    maptile dst_tile = maptile_at( dst );
    const field_entry *tmpfld = dst_tile.get_field().find_field( cur.get_field_type() );
    // Candidates are existing weaker fields or navigable/flagged tiles with no field.
    if( tmpfld == nullptr || tmpfld->get_field_intensity() < cur.get_field_intensity() ) {
        const ter_t &ter = dst_tile.get_ter_t();
        const furn_t &frn = dst_tile.get_furn_t();
        return !obstructed_by_vehicle_rotation( src, dst ) &&
               ( ter_furn_movecost( ter, frn ) > 0 || ter_furn_has_flag( ter, frn, TFLAG_PERMEABLE ) );
    }
    return false;
}

References field::find_field(), maptile::get_field(), field_entry::get_field_intensity(), field_entry::get_field_type(), maptile::get_furn_t(), maptile::get_ter_t(), maptile_at(), obstructed_by_vehicle_rotation(), ter(), ter_furn_has_flag(), ter_furn_movecost(), and TFLAG_PERMEABLE.

Referenced by spread_gas().

◆ gas_spread_to()

void map::gas_spread_to	(	field_entry &	cur,
		maptile &	dst,
		const tripoint &	p
	)

private

Definition at line 226 of file map_field.cpp.

{
    const field_type_id current_type = cur.get_field_type();
    const time_duration current_age = cur.get_field_age();
    const int current_intensity = cur.get_field_intensity();
    field_entry *f = dst.find_field( current_type );
    // Nearby gas grows thicker, and ages are shared.
    const time_duration age_fraction = current_age / current_intensity;
    if( f != nullptr ) {
        f->set_field_intensity( f->get_field_intensity() + 1 );
        cur.set_field_intensity( current_intensity - 1 );
        f->set_field_age( f->get_field_age() + age_fraction );
        cur.set_field_age( current_age - age_fraction );
        // Or, just create a new field.
    } else if( add_field( p, current_type, 1, 0_turns ) ) {
        f = dst.find_field( current_type );
        if( f != nullptr ) {
            f->set_field_age( age_fraction );
        } else {
            debugmsg( "While spreading the gas, field was added but doesn't exist." );
        }
        cur.set_field_intensity( current_intensity - 1 );
        cur.set_field_age( current_age - age_fraction );
    }
}

References add_field(), debugmsg, maptile::find_field(), field_entry::get_field_age(), field_entry::get_field_intensity(), field_entry::get_field_type(), field_entry::set_field_age(), and field_entry::set_field_intensity().

Referenced by spread_gas().

◆ generate()

void map::generate	(	const tripoint &	p,
		const time_point &	when
	)

Definition at line 109 of file mapgen.cpp.

{
    dbg( DL::Info ) << "map::generate( g[" << g.get() << "], p[" << p <<
                    "], when[" << to_string( when ) << "] )";
 
    set_abs_sub( p );
 
    // First we have to create new submaps and initialize them to 0 all over
    // We create all the submaps, even if we're not a tinymap, so that map
    //  generation which overflows won't cause a crash.  At the bottom of this
    //  function, we save the upper-left 4 submaps, and delete the rest.
    // Mapgen is not z-level aware yet. Only actually initialize current z-level
    //  because other submaps won't be touched.
    for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
        for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
            const size_t grid_pos = get_nonant( { gridx, gridy, p.z } );
            if( getsubmap( grid_pos ) ) {
                debugmsg( "Submap already exists at (%d, %d, %d)", gridx, gridy, p.z );
                continue;
            }
            setsubmap( grid_pos, new submap() );
            // TODO: memory leak if the code below throws before the submaps get stored/deleted!
        }
    }
    // x, and y are submap coordinates, convert to overmap terrain coordinates
    // TODO: fix point types
    tripoint_abs_omt abs_omt( sm_to_omt_copy( p ) );
    oter_id terrain_type = overmap_buffer.ter( abs_omt );
 
    // This attempts to scale density of zombies inversely with distance from the nearest city.
    // In other words, make city centers dense and perimeters sparse.
    float density = 0.0;
    for( int i = -MON_RADIUS; i <= MON_RADIUS; i++ ) {
        for( int j = -MON_RADIUS; j <= MON_RADIUS; j++ ) {
            density += overmap_buffer.ter( abs_omt + point( i, j ) )->get_mondensity();
        }
    }
    density = density / 100;
 
    mapgendata dat( abs_omt, *this, density, when, nullptr );
    draw_map( dat );
 
    // At some point, we should add region information so we can grab the appropriate extras
    map_extras ex = region_settings_map["default"].region_extras[terrain_type->get_extras()];
    if( ex.chance > 0 && one_in( ex.chance ) ) {
        std::string *extra = ex.values.pick();
        if( extra == nullptr ) {
            debugmsg( "failed to pick extra for type %s", terrain_type->get_extras() );
        } else {
            MapExtras::apply_function( *( ex.values.pick() ), *this, abs_sub );
        }
    }
 
    const auto &spawns = terrain_type->get_static_spawns();
 
    float spawn_density = 1.0f;
    if( MonsterGroupManager::is_animal( spawns.group ) ) {
        spawn_density = get_option< float >( "SPAWN_ANIMAL_DENSITY" );
    } else {
        spawn_density = get_option< float >( "SPAWN_DENSITY" );
    }
 
    // Apply a multiplier to the number of monsters for really high densities.
    float odds_after_density = spawns.chance * spawn_density;
    const float max_odds = 100 - ( 100 - spawns.chance ) / 2.0;
    float density_multiplier = 1.0f;
    if( odds_after_density > max_odds ) {
        density_multiplier = 1.0f * odds_after_density / max_odds;
        odds_after_density = max_odds;
    }
    const int spawn_count = roll_remainder( density_multiplier );
 
    if( spawns.group && x_in_y( odds_after_density, 100 ) ) {
        int pop = spawn_count * rng( spawns.population.min, spawns.population.max );
        for( ; pop > 0; pop-- ) {
            MonsterGroupResult spawn_details = MonsterGroupManager::GetResultFromGroup( spawns.group, &pop );
            if( !spawn_details.name ) {
                continue;
            }
            if( const std::optional<tripoint> pt =
            random_point( *this, [this]( const tripoint & n ) {
            return passable( n );
            } ) ) {
                add_spawn( spawn_details.name, spawn_details.pack_size, *pt );
            }
        }
    }
 
    cata::run_on_mapgen_postprocess_hooks(
        *DynamicDataLoader::get_instance().lua,
        *this,
        sm_to_omt_copy( p ),
        when
    );
 
    // Okay, we know who are neighbors are.  Let's draw!
    // And finally save used submaps and delete the rest.
    for( int i = 0; i < my_MAPSIZE; i++ ) {
        for( int j = 0; j < my_MAPSIZE; j++ ) {
            dbg( DL::Info ) << "map::generate: submap (" << i << "," << j << ")";
 
            const tripoint pos( i, j, p.z );
            if( i <= 1 && j <= 1 ) {
                saven( pos );
            } else {
                const size_t grid_pos = get_nonant( pos );
                delete getsubmap( grid_pos );
                setsubmap( grid_pos, nullptr );
            }
        }
    }
}

References abs_sub, add_spawn(), MapExtras::apply_function(), map_extras::chance, dbg, debugmsg, draw_map(), g, oter_t::get_extras(), DynamicDataLoader::get_instance(), oter_t::get_mondensity(), get_nonant(), oter_t::get_static_spawns(), MonsterGroupManager::GetResultFromGroup(), getsubmap(), Info, MonsterGroupManager::is_animal(), MON_RADIUS, my_MAPSIZE, MonsterGroupResult::name, one_in(), overmap_buffer, MonsterGroupResult::pack_size, passable(), random_point(), region_settings_map, rng(), roll_remainder(), cata::run_on_mapgen_postprocess_hooks(), saven(), set_abs_sub(), setsubmap(), sm_to_omt_copy(), overmapbuffer::ter(), to_string(), map_extras::values, x_in_y(), and tripoint::z.

Referenced by farm_action(), defense_game::init_map(), loadn(), and editmap::mapgen_preview().

◆ generate_lightmap()

void map::generate_lightmap ( int zlev )

protected

Definition at line 436 of file lightmap.cpp.

{
    auto &map_cache = get_cache( zlev );
    auto &lm = map_cache.lm;
    auto &sm = map_cache.sm;
    auto &outside_cache = map_cache.outside_cache;
    auto &prev_floor_cache = get_cache( clamp( zlev + 1, -OVERMAP_DEPTH, OVERMAP_DEPTH ) ).floor_cache;
    bool top_floor = zlev == OVERMAP_DEPTH;
    std::memset( lm, 0, sizeof( lm ) );
    std::memset( sm, 0, sizeof( sm ) );
 
    /* Bulk light sources wastefully cast rays into neighbors; a burning hospital can produce
         significant slowdown, so for stuff like fire and lava:
     * Step 1: Store the position and luminance in buffer via add_light_source, for efficient
         checking of neighbors.
     * Step 2: After everything else, iterate buffer and apply_light_source only in non-redundant
         directions
     * Step 3: ????
     * Step 4: Profit!
     */
    auto &light_source_buffer = map_cache.light_source_buffer;
    std::memset( light_source_buffer, 0, sizeof( light_source_buffer ) );
 
    constexpr std::array<int, 4> dir_x = { {  0, -1, 1, 0 } };    //    [0]
    constexpr std::array<int, 4> dir_y = { { -1,  0, 0, 1 } };    // [1][X][2]
    constexpr std::array<int, 4> dir_d = { { 90, 0, 180, 270 } }; //    [3]
    constexpr std::array<std::array<quadrant, 2>, 4> dir_quadrants = { {
            {{ quadrant::NE, quadrant::NW }},
            {{ quadrant::SW, quadrant::NW }},
            {{ quadrant::SE, quadrant::NE }},
            {{ quadrant::SE, quadrant::SW }},
        }
    };
 
    const float natural_light = g->natural_light_level( zlev );
 
    build_sunlight_cache( zlev );
 
    apply_character_light( get_player_character() );
    for( npc &guy : g->all_npcs() ) {
        apply_character_light( guy );
    }
 
    std::vector<std::pair<tripoint, float>> lm_override;
    // Traverse the submaps in order
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const auto cur_submap = get_submap_at_grid( { smx, smy, zlev } );
 
            for( int sx = 0; sx < SEEX; ++sx ) {
                for( int sy = 0; sy < SEEY; ++sy ) {
                    const int x = sx + smx * SEEX;
                    const int y = sy + smy * SEEY;
                    const tripoint p( x, y, zlev );
                    // Project light into any openings into buildings.
                    if( !outside_cache[p.x][p.y] || ( !top_floor && prev_floor_cache[p.x][p.y] ) ) {
                        // Apply light sources for external/internal divide
                        for( int i = 0; i < 4; ++i ) {
                            point neighbour = p.xy() + point( dir_x[i], dir_y[i] );
                            if( lightmap_boundaries.contains( neighbour )
                                && outside_cache[neighbour.x][neighbour.y] &&
                                ( top_floor || !prev_floor_cache[neighbour.x][neighbour.y] )
                              ) {
                                const float source_light =
                                    std::min( natural_light, lm[neighbour.x][neighbour.y].max() );
                                if( light_transparency( p ) > LIGHT_TRANSPARENCY_SOLID ) {
                                    update_light_quadrants( lm[p.x][p.y], source_light, quadrant::default_ );
                                    apply_directional_light( p, dir_d[i], source_light );
                                } else {
                                    update_light_quadrants( lm[p.x][p.y], source_light, dir_quadrants[i][0] );
                                    update_light_quadrants( lm[p.x][p.y], source_light, dir_quadrants[i][1] );
                                }
                            }
                        }
                    }
 
                    if( cur_submap->get_lum( { sx, sy } ) && has_items( p ) ) {
                        auto items = i_at( p );
                        add_light_from_items( p, items.begin(), items.end() );
                    }
 
                    const ter_id terrain = cur_submap->get_ter( { sx, sy } );
                    if( terrain->light_emitted > 0 ) {
                        add_light_source( p, terrain->light_emitted );
                    }
                    const furn_id furniture = cur_submap->get_furn( {sx, sy } );
                    if( furniture->light_emitted > 0 ) {
                        add_light_source( p, furniture->light_emitted );
                    }
 
                    for( auto &fld : cur_submap->get_field( { sx, sy } ) ) {
                        const field_entry *cur = &fld.second;
                        const int light_emitted = cur->light_emitted();
                        if( light_emitted > 0 ) {
                            add_light_source( p, light_emitted );
                        }
                        const float light_override = cur->local_light_override();
                        if( light_override >= 0.0 ) {
                            lm_override.push_back( std::pair<tripoint, float>( p, light_override ) );
                        }
                    }
                }
            }
        }
    }
 
    for( monster &critter : g->all_monsters() ) {
        if( critter.is_hallucination() ) {
            continue;
        }
        const tripoint &mp = critter.pos();
        if( inbounds( mp ) ) {
            if( critter.has_effect( effect_onfire ) ) {
                apply_light_source( mp, 8 );
            }
            // TODO: [lightmap] Attach natural light brightness to creatures
            // TODO: [lightmap] Allow creatures to have light attacks (i.e.: eyebot)
            // TODO: [lightmap] Allow creatures to have facing and arc lights
            if( critter.type->luminance > 0 ) {
                apply_light_source( mp, critter.type->luminance );
            }
        }
    }
 
    // Apply any vehicle light sources
    VehicleList vehs = get_vehicles();
    for( auto &vv : vehs ) {
        vehicle *v = vv.v;
 
        auto lights = v->lights( true );
 
        float veh_luminance = 0.0;
        float iteration = 1.0;
 
        for( const auto pt : lights ) {
            const auto &vp = pt->info();
            if( vp.has_flag( VPFLAG_CONE_LIGHT ) ||
                vp.has_flag( VPFLAG_WIDE_CONE_LIGHT ) ) {
                veh_luminance += vp.bonus / iteration;
                iteration = iteration * 1.1;
            }
        }
 
        for( const auto pt : lights ) {
            const auto &vp = pt->info();
            tripoint src = v->global_part_pos3( *pt );
 
            if( !inbounds( src ) ) {
                continue;
            }
 
            if( vp.has_flag( VPFLAG_CONE_LIGHT ) ) {
                if( veh_luminance > lit_level::LIT ) {
                    add_light_source( src, M_SQRT2 ); // Add a little surrounding light
                    apply_light_arc( src, v->face.dir() + pt->direction, veh_luminance,
                                     45_degrees );
                }
 
            } else if( vp.has_flag( VPFLAG_WIDE_CONE_LIGHT ) ) {
                if( veh_luminance > lit_level::LIT ) {
                    add_light_source( src, M_SQRT2 ); // Add a little surrounding light
                    apply_light_arc( src, v->face.dir() + pt->direction, veh_luminance,
                                     90_degrees );
                }
 
            } else if( vp.has_flag( VPFLAG_HALF_CIRCLE_LIGHT ) ) {
                add_light_source( src, M_SQRT2 ); // Add a little surrounding light
                apply_light_arc( src, v->face.dir() + pt->direction, vp.bonus, 180_degrees );
 
            } else if( vp.has_flag( VPFLAG_CIRCLE_LIGHT ) ) {
                const bool odd_turn = calendar::once_every( 2_turns );
                if( ( odd_turn && vp.has_flag( VPFLAG_ODDTURN ) ) ||
                    ( !odd_turn && vp.has_flag( VPFLAG_EVENTURN ) ) ||
                    ( !( vp.has_flag( VPFLAG_EVENTURN ) || vp.has_flag( VPFLAG_ODDTURN ) ) ) ) {
 
                    add_light_source( src, vp.bonus );
                }
 
            } else {
                add_light_source( src, vp.bonus );
            }
        }
 
        for( const vpart_reference &vp : v->get_all_parts() ) {
            const size_t p = vp.part_index();
            const tripoint pp = vp.pos();
            if( !inbounds( pp ) ) {
                continue;
            }
            if( vp.has_feature( VPFLAG_CARGO ) && !vp.has_feature( "COVERED" ) ) {
                add_light_from_items( pp, v->get_items( static_cast<int>( p ) ).begin(),
                                      v->get_items( static_cast<int>( p ) ).end() );
            }
        }
    }
 
    /* Now that we have position and intensity of all bulk light sources, apply_ them
      This may seem like extra work, but take a 12x12 raging inferno:
        unbuffered: (12^2)*(160*4) = apply_light_ray x 92160
        buffered:   (12*4)*(160)   = apply_light_ray x 7680
    */
    const tripoint cache_start( 0, 0, zlev );
    const tripoint cache_end( LIGHTMAP_CACHE_X, LIGHTMAP_CACHE_Y, zlev );
    for( const tripoint &p : points_in_rectangle( cache_start, cache_end ) ) {
        if( light_source_buffer[p.x][p.y] > 0.0 ) {
            apply_light_source( p, light_source_buffer[p.x][p.y] );
        }
    }
    for( const std::pair<tripoint, float> &elem : lm_override ) {
        lm[elem.first.x][elem.first.y].fill( elem.second );
    }
}

References add_light_from_items(), add_light_source(), apply_character_light(), apply_directional_light(), apply_light_arc(), apply_light_source(), item_stack::begin(), build_sunlight_cache(), clamp(), default_, tileray::dir(), effect_onfire, item_stack::end(), vehicle::face, level_cache::floor_cache, furniture, g, vehicle::get_all_parts(), get_cache(), vehicle::get_items(), get_player_character(), get_submap_at_grid(), get_vehicles(), vehicle::global_part_pos3(), has_items(), i_at(), inbounds(), field_entry::light_emitted(), light_transparency(), LIGHT_TRANSPARENCY_SOLID, lightmap_boundaries, LIGHTMAP_CACHE_X, LIGHTMAP_CACHE_Y, vehicle::lights(), LIT, field_entry::local_light_override(), M_SQRT2, my_MAPSIZE, NE, NW, calendar::once_every(), OVERMAP_DEPTH, points_in_rectangle(), SE, SEEX, SEEY, coords::sm, SW, sx, sy, terrain, update_light_quadrants(), VPFLAG_CARGO, VPFLAG_CIRCLE_LIGHT, VPFLAG_CONE_LIGHT, VPFLAG_EVENTURN, VPFLAG_HALF_CIRCLE_LIGHT, VPFLAG_ODDTURN, VPFLAG_WIDE_CONE_LIGHT, point::x, tripoint::x, tripoint::xy(), point::y, and tripoint::y.

Referenced by build_map_cache().

◆ get_abs_sub()

tripoint map::get_abs_sub ( ) const

return abs_sub

Definition at line 8433 of file map.cpp.

{
    return abs_sub;
}

References abs_sub.

Referenced by add_corpse(), jmapgen_field::apply(), jmapgen_sign::apply(), jmapgen_graffiti::apply(), jmapgen_liquid_item::apply(), jmapgen_loot::apply(), jmapgen_trap::apply(), jmapgen_terrain::apply(), jmapgen_ter_furn_transform::apply(), jmapgen_make_rubble::apply(), jmapgen_computer::apply(), jmapgen_setmap::apply(), VehicleSpawnFunction::builtin_parkinglot(), start_location::burn(), calc_max_populated_zlev(), draw_lab(), find_potential_computer_point(), game::get_cur_om(), game::get_levx(), game::get_levy(), game::get_levz(), distribution_grid_tracker::load(), madd_field(), mapgen_ants_larvae(), mapgen_ants_larvae_acid(), mapgen_ants_queen(), mapgen_ants_queen_acid(), mapgen_cavern(), mapgen_crater(), mapgen_hive(), mapgen_road(), mremove_trap(), mtrap_set(), MapExtras::mx_house_spider(), MapExtras::mx_spider(), place_items(), start_location::place_player(), place_spawns(), points_in_range(), start_location::prepare_map(), rotate(), game::serialize(), shift(), and vertical_shift().

◆ get_active_items_in_radius() [1/2]

std::list< item_location > map::get_active_items_in_radius	(	const tripoint &	center,
		int	radius
	)		const

Definition at line 8788 of file map.cpp.

{
    return get_active_items_in_radius( center, radius, special_item_type::none );
}

References center, get_active_items_in_radius(), and none.

Referenced by npc::find_dangerous_explosives(), and get_active_items_in_radius().

◆ get_active_items_in_radius() [2/2]

std::list< item_location > map::get_active_items_in_radius	(	const tripoint &	center,
		int	radius,
		special_item_type	type
	)		const

Definition at line 8794 of file map.cpp.

{
    std::list<item_location> result;
 
    const point minp( center.xy() + point( -radius, -radius ) );
    const point maxp( center.xy() + point( radius, radius ) );
 
    const point ming( std::max( minp.x / SEEX, 0 ),
                      std::max( minp.y / SEEY, 0 ) );
    const point maxg( std::min( maxp.x / SEEX, my_MAPSIZE - 1 ),
                      std::min( maxp.y / SEEY, my_MAPSIZE - 1 ) );
 
    for( const tripoint &abs_submap_loc : submaps_with_active_items ) {
        const tripoint submap_loc{ -abs_sub.xy() + abs_submap_loc };
        if( submap_loc.x < ming.x || submap_loc.y < ming.y ||
            submap_loc.x > maxg.x || submap_loc.y > maxg.y ) {
            continue;
        }
        const point sm_offset( submap_loc.x * SEEX, submap_loc.y * SEEY );
 
        submap *sm = get_submap_at_grid( submap_loc );
        std::vector<item_reference> items = type == special_item_type::none ? sm->active_items.get() :
                                            sm->active_items.get_special( type );
        for( const auto &elem : items ) {
            const tripoint pos( sm_offset + elem.location, submap_loc.z );
 
            if( rl_dist( pos, center ) > radius ) {
                continue;
            }
 
            if( elem.item_ref ) {
                result.emplace_back( map_cursor( pos ), elem.item_ref.get() );
            }
        }
    }
 
    return result;
}

References abs_sub, center, get_submap_at_grid(), my_MAPSIZE, none, rl_dist(), SEEX, SEEY, coords::sm, submaps_with_active_items, type, point::x, tripoint::xy(), and point::y.

◆ get_cache()

level_cache & map::get_cache ( int zlev ) const

inlineprivate

Definition at line 1993 of file map.h.

                                                 {
            return *caches[zlev + OVERMAP_DEPTH];
        }

References caches, and OVERMAP_DEPTH.

Referenced by add_field(), add_light_source(), add_vehicle(), add_vehicle_to_cache(), apply_directional_light(), apply_light_ray(), apply_light_source(), apply_vision_transparency_cache(), build_floor_cache(), build_map_cache(), build_outside_cache(), build_seen_cache(), build_sunlight_cache(), build_transparency_cache(), check_and_set_seen_cache(), check_seen_cache(), check_vehicle_zones(), clear_vehicle_cache(), clear_vehicle_list(), clear_vehicle_point_from_cache(), editmap::cleartmpmap(), decay_fields_and_scent(), detach_vehicle(), displace_vehicle(), do_vehicle_caching(), generate_lightmap(), get_vehicle_zones(), has_field_at(), invalidate_map_cache(), loadn(), obscured_by_vehicle_rotation(), obstructed_by_vehicle_rotation(), process_fields(), process_fields_in_submap(), register_vehicle_zone(), remove_field(), reset_vehicle_cache(), restore_vision_transparency_cache(), set_floor_cache_dirty(), set_memory_seen_cache_dirty(), set_outside_cache_dirty(), set_seen_cache_dirty(), set_suspension_cache_dirty(), set_transparency_cache_dirty(), shift(), shift_vehicle_z(), ter_set(), update_suspension_cache(), update_vehicle_list(), update_visibility_cache(), veh_at(), veh_at_internal(), vehmove(), and vehproceed().

◆ get_cache_ref()

const level_cache & map::get_cache_ref ( int zlev ) const

inline

Definition at line 2006 of file map.h.

                                                           {
            return *caches[zlev + OVERMAP_DEPTH];
        }

References caches, and OVERMAP_DEPTH.

Referenced by ambient_light_at(), apparent_light_at(), build_sunlight_cache(), decay_fields_and_scent(), draw(), generate_weather_anim_frame(), has_floor(), is_outside(), light_at(), light_transparency(), pl_line_of_sight(), pl_sees(), and update_visibility_cache().

◆ get_creatures_in_radius()

std::list< Creature * > map::get_creatures_in_radius	(	const tripoint &	center,
		size_t	radius,
		size_t	radiusz = `0`
	)

returns creatures in specified radius

Definition at line 8876 of file map.cpp.

{
    std::list<Creature *> creatures;
    for( const auto &loc : points_in_radius( center, radius, radiusz ) ) {
        Creature *tmp_critter = g->critter_at( loc );
        if( tmp_critter != nullptr ) {
            creatures.push_back( tmp_critter );
        }
 
    }
    return creatures;
}

References center, g, and points_in_radius().

◆ get_dir_circle()

std::vector< tripoint > map::get_dir_circle	(	const tripoint &	f,
		const tripoint &	t
	)		const

Calculate next search points surrounding the current position.

Points closer to the target come first. This method leads to straighter lines and prevents weird looking movements away from the target.

Definition at line 6701 of file map.cpp.

{
    std::vector<tripoint> circle;
    circle.resize( 8 );
 
    // The line below can be crazy expensive - we only take the FIRST point of it
    const std::vector<tripoint> line = line_to( f, t, 0, 0 );
    const std::vector<tripoint> spiral = closest_points_first( f, 1 );
    const std::vector<int> pos_index {1, 2, 4, 6, 8, 7, 5, 3};
 
    //  All possible constellations (closest_points_first goes clockwise)
    //  753  531  312  124  246  468  687  875
    //  8 1  7 2  5 4  3 6  1 8  2 7  4 5  6 3
    //  642  864  786  578  357  135  213  421
 
    size_t pos_offset = 0;
    for( size_t i = 1; i < spiral.size(); i++ ) {
        if( spiral[i] == line[0] ) {
            pos_offset = i - 1;
            break;
        }
    }
 
    for( size_t i = 1; i < spiral.size(); i++ ) {
        if( pos_offset >= pos_index.size() ) {
            pos_offset = 0;
        }
 
        circle[pos_index[pos_offset++] - 1] = spiral[i];
    }
 
    return circle;
}

References circle(), closest_points_first(), line(), and line_to().

◆ get_field() [1/2]

field & map::get_field ( const tripoint & p )

private

Definition at line 8624 of file map.cpp.

{
    return field_at( p );
}

References field_at().

◆ get_field() [2/2]

field_entry * map::get_field	(	const tripoint &	p,
		const field_type_id &	type
	)

Get field of specific type at point.

Returns: NULL if there is no such field entry at that place.

Definition at line 5513 of file map.cpp.

{
    if( !inbounds( p ) || !has_field_at( p, false ) ) {
        return nullptr;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_field( l ).find_field( type );
}

References field::find_field(), submap::get_field(), get_submap_at(), has_field_at(), inbounds(), and type.

Referenced by add_item(), bash_field(), creature_in_field(), has_nearby_fire(), monster_in_field(), player_in_field(), process_fields_in_submap(), set_field_age(), set_field_intensity(), and shoot().

◆ get_field_age()

time_duration map::get_field_age	(	const tripoint &	p,
		const field_type_id &	type
	)		const

Get the age of a field entry (field_entry::age), if there is no field of that type, returns -1_turns.

Definition at line 5494 of file map.cpp.

{
    auto field_ptr = field_at( p ).find_field( type );
    return field_ptr == nullptr ? -1_turns : field_ptr->get_field_age();
}

References field_at(), field::find_field(), field_entry::get_field_age(), and type.

Referenced by game::grabbed_furn_move(), and game::walk_move().

◆ get_field_intensity()

int map::get_field_intensity	(	const tripoint &	p,
		const field_type_id &	type
	)		const

Get the intensity of a field entry (field_entry::intensity), if there is no field of that type, returns 0.

Definition at line 5500 of file map.cpp.

{
    auto field_ptr = field_at( p ).find_field( type );
    return ( field_ptr == nullptr ? 0 : field_ptr->get_field_intensity() );
}

References field_at(), field::find_field(), and type.

Referenced by game::grabbed_furn_move(), is_flammable(), propagate_field(), fungal_effects::spread_fungus_one_tile(), and game::walk_move().

◆ get_furn_field_locations()

const std::vector< tripoint > & map::get_furn_field_locations ( ) const

Definition at line 7888 of file map.cpp.

{
    return field_furn_locs;
}

References field_furn_locs.

Referenced by game::do_turn().

◆ get_furn_transforms_into()

furn_id map::get_furn_transforms_into ( const tripoint & p ) const

Definition at line 1677 of file map.cpp.

{
    return furn( p ).obj().transforms_into.id();
}

References furn(), string_id< T >::id(), int_id< T >::obj(), and furn_t::transforms_into.

◆ get_harvest()

const harvest_id & map::get_harvest ( const tripoint & p ) const

Returns the full harvest list, for spawning.

Definition at line 1629 of file map.cpp.

{
    const auto furn_here = furn( pos );
    if( furn_here->examine != iexamine::none ) {
        // Note: if furniture can be examined, the terrain can NOT (until furniture is removed)
        if( furn_here->has_flag( TFLAG_HARVESTED ) ) {
            return harvest_id::NULL_ID();
        }
 
        return furn_here->get_harvest();
    }
 
    const auto ter_here = ter( pos );
    if( ter_here->has_flag( TFLAG_HARVESTED ) ) {
        return harvest_id::NULL_ID();
    }
 
    return ter_here->get_harvest();
}

References furn(), iexamine::none(), string_id< harvest_list >::NULL_ID(), wrapped_vehicle::pos, ter(), and TFLAG_HARVESTED.

Referenced by is_harvestable().

◆ get_harvest_names()

const std::set< std::string > & map::get_harvest_names ( const tripoint & p ) const

Returns names of the items that would be dropped.

Definition at line 1649 of file map.cpp.

{
    static const std::set<std::string> null_harvest_names = {};
    const auto furn_here = furn( pos );
    if( furn_here->examine != iexamine::none ) {
        if( furn_here->has_flag( TFLAG_HARVESTED ) ) {
            return null_harvest_names;
        }
 
        return furn_here->get_harvest_names();
    }
 
    const auto ter_here = ter( pos );
    if( ter_here->has_flag( TFLAG_HARVESTED ) ) {
        return null_harvest_names;
    }
 
    return ter_here->get_harvest_names();
}

References furn(), iexamine::none(), wrapped_vehicle::pos, ter(), and TFLAG_HARVESTED.

◆ get_known_connections()

uint8_t map::get_known_connections	(	const tripoint &	p,
		int	connect_group,
		const std::map< tripoint, ter_id > &	override = `{}`
	)		const

Definition at line 1575 of file map.cpp.

{
    auto &ch = access_cache( p.z );
    uint8_t val = 0;
    std::function<bool( const tripoint & )> is_memorized;
#ifdef TILES
    if( use_tiles ) {
        is_memorized =
        [&]( const tripoint & q ) {
            return !g->u.get_memorized_tile( getabs( q ) ).tile.empty();
        };
    } else {
#endif
        is_memorized =
        [&]( const tripoint & q ) {
            return g->u.get_memorized_symbol( getabs( q ) );
        };
#ifdef TILES
    }
#endif
 
    const bool overridden = override.find( p ) != override.end();
    const bool is_transparent = ch.transparency_cache[p.x][p.y] > LIGHT_TRANSPARENCY_SOLID;
 
    // populate connection information
    for( int i = 0; i < 4; ++i ) {
        tripoint neighbour = p + offsets[i];
        if( !inbounds( neighbour ) ) {
            continue;
        }
        const auto neighbour_override = override.find( neighbour );
        const bool neighbour_overridden = neighbour_override != override.end();
        // if there's some non-memory terrain to show at the neighboring tile
        const bool may_connect = neighbour_overridden ||
                                 get_visibility( ch.visibility_cache[neighbour.x][neighbour.y],
                                         get_visibility_variables_cache() ) == VIS_CLEAR ||
                                 // or if an actual center tile is transparent or next to a memorized tile
                                 ( !overridden && ( is_transparent || is_memorized( neighbour ) ) );
        if( may_connect ) {
            const ter_t &neighbour_terrain = neighbour_overridden ?
                                             neighbour_override->second.obj() : ter( neighbour ).obj();
            if( neighbour_terrain.connects_to( connect_group ) ) {
                val += 1 << i;
            }
        }
    }
 
    return val;
}

References access_cache(), map_data_common_t::connects_to(), g, get_visibility(), get_visibility_variables_cache(), getabs(), inbounds(), is_transparent(), LIGHT_TRANSPARENCY_SOLID, int_id< T >::obj(), offsets, ter(), use_tiles, VIS_CLEAR, tripoint::x, tripoint::y, and tripoint::z.

Referenced by determine_wall_corner().

◆ get_neighbors()

std::array< std::pair< tripoint, maptile >, 8 > map::get_neighbors ( const tripoint & p )

private

Definition at line 191 of file map_field.cpp.

{
    // Find out which edges are in the bubble
    // Where possible, do just one bounds check for all the neighbors
    const bool west = p.x > 0;
    const bool north = p.y > 0;
    const bool east = p.x < SEEX * my_MAPSIZE - 1;
    const bool south = p.y < SEEY * my_MAPSIZE - 1;
    return std::array< std::pair<tripoint, maptile>, 8 > { {
            maptile_has_bounds( p + eight_horizontal_neighbors[0], west &&north ),
            maptile_has_bounds( p + eight_horizontal_neighbors[1], north ),
            maptile_has_bounds( p + eight_horizontal_neighbors[2], east &&north ),
            maptile_has_bounds( p + eight_horizontal_neighbors[3], west ),
            maptile_has_bounds( p + eight_horizontal_neighbors[4], east ),
            maptile_has_bounds( p + eight_horizontal_neighbors[5], west &&south ),
            maptile_has_bounds( p + eight_horizontal_neighbors[6], south ),
            maptile_has_bounds( p + eight_horizontal_neighbors[7], east &&south ),
        }
    };
}

References eight_horizontal_neighbors, maptile_has_bounds(), my_MAPSIZE, SEEX, SEEY, tripoint::x, and tripoint::y.

Referenced by process_fields_in_submap(), and spread_gas().

◆ get_nonant() [1/2]

size_t map::get_nonant ( const tripoint & gridp ) const

protected

Get the index of a submap pointer in the grid given by grid coordinates.

The grid coordinates must be valid: 0 <= x < my_MAPSIZE, same for y. Version with z-levels checks for z between -OVERMAP_DEPTH and OVERMAP_HEIGHT

Definition at line 8480 of file map.cpp.

{
    // There used to be a bounds check here
    // But this function is called a lot, so push it up if needed
    if( zlevels ) {
        const int indexz = gridp.z + OVERMAP_HEIGHT; // Can't be lower than 0
        return indexz + ( gridp.x + gridp.y * my_MAPSIZE ) * OVERMAP_LAYERS;
    } else {
        return gridp.x + gridp.y * my_MAPSIZE;
    }
}

References my_MAPSIZE, OVERMAP_HEIGHT, OVERMAP_LAYERS, tripoint::x, tripoint::y, tripoint::z, and zlevels.

Referenced by copy_grid(), fake_map::fake_map(), generate(), get_nonant(), get_submap_at_grid(), loadn(), and saven().

◆ get_nonant() [2/2]

size_t map::get_nonant ( point gridp ) const

inlineprotected

Definition at line 1847 of file map.h.

                                               {
            return get_nonant( { gridp, abs_sub.z } );
        }

References abs_sub, get_nonant(), and tripoint::z.

◆ get_pathfinding_cache()

pathfinding_cache & map::get_pathfinding_cache ( int zlev ) const

private

Definition at line 8940 of file map.cpp.

{
    return *pathfinding_caches[zlev + OVERMAP_DEPTH];
}

References OVERMAP_DEPTH, and pathfinding_caches.

Referenced by get_pathfinding_cache_ref(), set_pathfinding_cache_dirty(), and update_pathfinding_cache().

◆ get_pathfinding_cache_ref()

const pathfinding_cache & map::get_pathfinding_cache_ref ( int zlev ) const

Definition at line 8990 of file map.cpp.

{
    if( !inbounds_z( zlev ) ) {
        debugmsg( "Tried to get pathfinding cache for out of bounds z-level %d", zlev );
        return *pathfinding_caches[ OVERMAP_DEPTH ];
    }
    auto &cache = get_pathfinding_cache( zlev );
    if( cache.dirty ) {
        update_pathfinding_cache( zlev );
    }
 
    return cache;
}

References debugmsg, get_pathfinding_cache(), inbounds_z(), OVERMAP_DEPTH, pathfinding_caches, and update_pathfinding_cache().

Referenced by route(), and vertical_move_destination().

◆ get_radiation()

int map::get_radiation ( const tripoint & p ) const

Definition at line 4154 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return 0;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_radiation( l );
}

References submap::get_radiation(), get_submap_at(), and inbounds().

Referenced by relic_funcs::check_recharge_reqs(), editmap::draw_main_ui_overlay(), and rad_scorch().

◆ get_roof()

ter_id map::get_roof	(	const tripoint &	p,
		bool	allow_air
	)		const

private

Definition at line 3202 of file map.cpp.

{
    // This function should not be called from the 2D mode
    // Just use t_dirt instead
    assert( zlevels );
 
    if( p.z <= -OVERMAP_DEPTH ) {
        // Could be magma/"void" instead
        return t_rock_floor;
    }
 
    const auto &ter_there = ter( p ).obj();
    const auto &roof = ter_there.roof;
    if( !roof ) {
        // No roof
        if( !allow_air ) {
            // TODO: Biomes? By setting? Forbid and treat as bug?
            if( p.z < 0 ) {
                return t_rock_floor_no_roof;
            }
 
            return t_dirt;
        }
 
        return t_open_air;
    }
 
    ter_id new_ter = roof.id();
    if( new_ter == t_null ) {
        debugmsg( "map::get_new_floor: %d,%d,%d has invalid roof type %s",
                  p.x, p.y, p.z, roof.c_str() );
        return t_dirt;
    }
 
    if( p.z == -1 && new_ter == t_rock_floor ) {
        // HACK: A hack to work around not having a "solid earth" tile
        new_ter = t_dirt;
    }
 
    return new_ter;
}

References debugmsg, int_id< T >::id(), int_id< T >::obj(), OVERMAP_DEPTH, ter_t::roof, t_dirt, t_null, t_open_air, t_rock_floor, t_rock_floor_no_roof, ter(), tripoint::x, tripoint::y, tripoint::z, and zlevels.

Referenced by bash_ter_furn(), and bash_ter_success().

◆ get_signage()

std::string map::get_signage ( const tripoint & p ) const

Definition at line 4120 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return "";
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_signage( l );
}

References submap::get_signage(), get_submap_at(), and inbounds().

Referenced by game::extended_description(), game::place_player(), and game::print_terrain_info().

◆ get_submap_at() [1/4]

submap * map::get_submap_at ( const tripoint & p ) const

private

Get the submap pointer containing the specified position within the reality bubble.

(p) must be a valid coordinate, check with inbounds.

Definition at line 8459 of file map.cpp.

{
    if( !inbounds( p ) ) {
        debugmsg( "Tried to access invalid map position (%d, %d, %d)", p.x, p.y, p.z );
        return nullptr;
    }
    return get_submap_at_grid( { p.x / SEEX, p.y / SEEY, p.z } );
}

References debugmsg, get_submap_at_grid(), inbounds(), SEEX, SEEY, tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_computer(), add_field(), add_item(), add_spawn(), adjust_radiation(), computer_at(), delete_graffiti(), delete_signage(), displace_vehicle(), field_at(), furn(), furn_set(), get_field(), get_radiation(), get_signage(), get_submap_at(), get_temperature(), graffiti_at(), has_flag_ter_or_furn(), has_graffiti_at(), has_items(), hoist_submap_camp(), i_at(), i_clear(), i_rem(), make_active(), maptile_at_internal(), move_cost_ter_furn(), partial_con_at(), partial_con_remove(), partial_con_set(), remove_field(), remove_submap_camp(), remove_trap(), set_graffiti(), set_radiation(), set_signage(), set_temperature(), shift_vehicle_z(), ter(), ter_set(), tr_at(), trap_set(), update_lum(), update_submap_active_item_status(), and update_suspension_cache().

◆ get_submap_at() [2/4]

submap * map::get_submap_at	(	const tripoint &	p,
		point &	offset_p
	)		const

private

Get the submap pointer containing the specified position within the reality bubble.

The same as other get_submap_at, (p) must be valid (inbounds). Also writes the position within the submap to offset_p

Definition at line 8468 of file map.cpp.

{
    offset_p.x = p.x % SEEX;
    offset_p.y = p.y % SEEY;
    return get_submap_at( p );
}

References get_submap_at(), SEEX, SEEY, point::x, tripoint::x, point::y, and tripoint::y.

◆ get_submap_at() [3/4]

submap * map::get_submap_at ( point p ) const

inlineprivate

Definition at line 1819 of file map.h.

                                               {
            return get_submap_at( tripoint( p, abs_sub.z ) );
        }

References abs_sub, get_submap_at(), and tripoint::z.

◆ get_submap_at() [4/4]

submap * map::get_submap_at	(	point	p,
		point &	offset_p
	)		const

inlineprivate

Definition at line 1828 of file map.h.

                                                                {
            return get_submap_at( { p, abs_sub.z }, offset_p );
        }

References abs_sub, get_submap_at(), and tripoint::z.

◆ get_submap_at_grid() [1/2]

submap * map::get_submap_at_grid ( const tripoint & gridp ) const

private

Definition at line 8475 of file map.cpp.

{
    return getsubmap( get_nonant( gridp ) );
}

References get_nonant(), and getsubmap().

◆ get_submap_at_grid() [2/2]

submap * map::get_submap_at_grid ( point gridp ) const

inlineprivate

Get submap pointer in the grid at given grid coordinates.

Grid coordinates must be valid: 0 <= x < my_MAPSIZE, same for y. z must be between -OVERMAP_DEPTH and OVERMAP_HEIGHT

Definition at line 1836 of file map.h.

                                                        {
            return getsubmap( get_nonant( gridp ) );
        }

References get_nonant(), and getsubmap().

Referenced by actualize(), add_roofs(), add_vehicle(), build_floor_cache(), build_obstacle_cache(), build_outside_cache(), build_transparency_cache(), calc_max_populated_zlev(), check_submap_active_item_consistency(), copy_grid(), decay_fields_and_scent(), detach_vehicle(), draw_fill_background(), editmap::draw_main_ui_overlay(), function_over(), generate_lightmap(), get_active_items_in_radius(), get_submap_at(), get_vehicles(), editmap::mapgen_preview(), editmap::mapgen_veh_destroy(), editmap::mapgen_veh_query(), process_fields(), process_fields_in_submap(), process_items(), rotate(), shift(), spawn_monsters_submap(), spawn_monsters_submap_group(), update_pathfinding_cache(), and update_suspension_cache().

◆ get_submaps_with_active_items()

const std::set< tripoint > & map::get_submaps_with_active_items ( ) const

inline

Definition at line 2020 of file map.h.

                                                                      {
            return submaps_with_active_items;
        }

References submaps_with_active_items.

◆ get_temperature()

int map::get_temperature ( const tripoint & p ) const

Definition at line 4191 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return 0;
    }
 
    return get_submap_at( p )->get_temperature();
}

References get_submap_at(), submap::get_temperature(), and inbounds().

◆ get_ter_transforms_into()

ter_id map::get_ter_transforms_into ( const tripoint & p ) const

Definition at line 1672 of file map.cpp.

{
    return ter( p ).obj().transforms_into.id();
}

References string_id< T >::id(), int_id< T >::obj(), ter(), and ter_t::transforms_into.

◆ get_vehicle_zones()

std::vector< zone_data * > map::get_vehicle_zones ( int zlev )

Definition at line 999 of file map.cpp.

{
    std::vector<zone_data *> veh_zones;
    bool rebuild = false;
    for( auto veh : get_cache( zlev ).zone_vehicles ) {
        if( veh->refresh_zones() ) {
            rebuild = true;
        }
        for( auto &zone : veh->loot_zones ) {
            veh_zones.emplace_back( &zone.second );
        }
    }
    if( rebuild ) {
        zone_manager::get_manager().cache_vzones();
    }
    return veh_zones;
}

References zone_manager::cache_vzones(), get_cache(), and zone_manager::get_manager().

Referenced by zone_manager::cache_vzones(), zone_manager::get_bottom_zone(), zone_manager::get_zone_at(), and zone_manager::get_zones().

◆ get_vehicles() [1/2]

VehicleList map::get_vehicles ( )

Definition at line 297 of file map.cpp.

{
    if( last_full_vehicle_list_dirty ) {
        if( !zlevels ) {
            last_full_vehicle_list = get_vehicles( tripoint( 0, 0, abs_sub.z ),
                                                   tripoint( SEEX * my_MAPSIZE, SEEY * my_MAPSIZE, abs_sub.z ) );
        } else {
            last_full_vehicle_list = get_vehicles( tripoint( 0, 0, -OVERMAP_DEPTH ),
                                                   tripoint( SEEX * my_MAPSIZE, SEEY * my_MAPSIZE, OVERMAP_HEIGHT ) );
        }
 
        last_full_vehicle_list_dirty = false;
    }
 
    return last_full_vehicle_list;
}

References abs_sub, get_vehicles(), last_full_vehicle_list, last_full_vehicle_list_dirty, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, SEEX, SEEY, tripoint::z, and zlevels.

Referenced by game::autopilot_vehicles(), build_obstacle_cache(), MapExtras::burned_ground_parser(), game::chat(), generate_lightmap(), get_vehicles(), MapExtras::mx_burned_ground(), scent_blockers(), game::start_game(), game::validate_linked_vehicles(), anonymous_namespace{iexamine_elevator.cpp}::elevator::vehicles_on(), and vehproceed().

◆ get_vehicles() [2/2]

VehicleList map::get_vehicles	(	const tripoint &	start,
		const tripoint &	end
	)

Definition at line 1040 of file map.cpp.

{
    const int chunk_sx = std::max( 0, ( start.x / SEEX ) - 1 );
    const int chunk_ex = std::min( my_MAPSIZE - 1, ( end.x / SEEX ) + 1 );
    const int chunk_sy = std::max( 0, ( start.y / SEEY ) - 1 );
    const int chunk_ey = std::min( my_MAPSIZE - 1, ( end.y / SEEY ) + 1 );
    const int chunk_sz = start.z;
    const int chunk_ez = end.z;
    VehicleList vehs;
 
    for( int cx = chunk_sx; cx <= chunk_ex; ++cx ) {
        for( int cy = chunk_sy; cy <= chunk_ey; ++cy ) {
            for( int cz = chunk_sz; cz <= chunk_ez; ++cz ) {
                submap *current_submap = get_submap_at_grid( { cx, cy, cz } );
                for( const auto &elem : current_submap->vehicles ) {
                    // Ensure the vehicle z-position is correct
                    elem->sm_pos.z = cz;
                    wrapped_vehicle w;
                    w.v = elem.get();
                    w.pos = w.v->global_pos3();
                    vehs.push_back( w );
                }
            }
        }
    }
 
    return vehs;
}

References get_submap_at_grid(), vehicle::global_pos3(), my_MAPSIZE, wrapped_vehicle::pos, SEEX, SEEY, wrapped_vehicle::v, submap::vehicles, tripoint::x, tripoint::y, and tripoint::z.

◆ get_visibility()

visibility_type map::get_visibility	(	lit_level	ll,
		const visibility_variables &	cache
	)		const

Definition at line 5790 of file map.cpp.

{
    switch( ll ) {
        case lit_level::DARK:
            // can't see this square at all
            if( cache.u_is_boomered ) {
                return VIS_BOOMER_DARK;
            } else {
                return VIS_DARK;
            }
        case lit_level::BRIGHT_ONLY:
            // can only tell that this square is bright
            if( cache.u_is_boomered ) {
                return VIS_BOOMER;
            } else {
                return VIS_LIT;
            }
 
        case lit_level::LOW:
        // low light, square visible in monochrome
        case lit_level::LIT:
        // normal light
        case lit_level::BRIGHT:
            // bright light
            return VIS_CLEAR;
        case lit_level::BLANK:
        case lit_level::MEMORIZED:
            return VIS_HIDDEN;
    }
    return VIS_HIDDEN;
}

References BLANK, BRIGHT, BRIGHT_ONLY, DARK, LIT, LOW, MEMORIZED, visibility_variables::u_is_boomered, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by draw(), game::draw_look_around_cursor(), generate_weather_anim_frame(), get_known_connections(), and game::print_all_tile_info().

◆ get_visibility_variables_cache()

const visibility_variables & map::get_visibility_variables_cache ( ) const

Definition at line 5785 of file map.cpp.

{
    return visibility_variables_cache;
}

References visibility_variables_cache.

Referenced by draw(), generate_weather_anim_frame(), get_known_connections(), game::look_around(), and live_view::show().

◆ get_wind_blockers()

std::tuple< maptile, maptile, maptile > map::get_wind_blockers	(	const int &	winddirection,
		const tripoint &	pos
	)

Definition at line 1894 of file map_field.cpp.

{
    static const std::array<std::pair<int, std::tuple< point, point, point >>, 9> outputs = {{
            { 330, std::make_tuple( point_east, point_north_east, point_south_east ) },
            { 301, std::make_tuple( point_south_east, point_east, point_south ) },
            { 240, std::make_tuple( point_south, point_south_west, point_south_east ) },
            { 211, std::make_tuple( point_south_west, point_west, point_south ) },
            { 150, std::make_tuple( point_west, point_north_west, point_south_west ) },
            { 121, std::make_tuple( point_north_west, point_north, point_west ) },
            { 60, std::make_tuple( point_north, point_north_west, point_north_east ) },
            { 31, std::make_tuple( point_north_east, point_east, point_north ) },
            { 0, std::make_tuple( point_east, point_north_east, point_south_east ) }
        }
    };
 
    tripoint removepoint;
    tripoint removepoint2;
    tripoint removepoint3;
    for( const std::pair<int, std::tuple< point, point, point >> &val : outputs ) {
        if( winddirection >= val.first ) {
            removepoint = pos + std::get<0>( val.second );
            removepoint2 = pos + std::get<1>( val.second );
            removepoint3 = pos + std::get<2>( val.second );
            break;
        }
    }
 
    const maptile remove_tile = maptile_at( removepoint );
    const maptile remove_tile2 = maptile_at( removepoint2 );
    const maptile remove_tile3 = maptile_at( removepoint3 );
    return std::make_tuple( remove_tile, remove_tile2, remove_tile3 );
}

References maptile_at(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, and point_west.

Referenced by spread_gas().

◆ getabs() [1/2]

tripoint map::getabs ( const tripoint & p ) const

Translates local (to this map) coordinates of a square to global absolute coordinates.

Coordinates is in the system that is used by the ter/furn/i_at functions. Output is in the same scale, but in global system.

Definition at line 8407 of file map.cpp.

{
    return sm_to_ms_copy( abs_sub.xy() ) + p;
}

References abs_sub, sm_to_ms_copy(), and tripoint::xy().

Referenced by add_item(), Character::add_known_trap(), jmapgen_zone::apply(), game::autopilot_vehicles(), bash_ter_furn(), game::check_near_zone(), game::check_zone(), game::control_vehicle(), activity_handlers::repair_activity_hack::anonymous_namespace{activity_handlers.cpp}::discharge_real_power_source(), npc::do_pulp(), draw_maptile(), fill_funnels(), game::find_or_make_stairs(), find_valid_teleporters_omt(), inventory::form_from_map(), furn_set(), activity_handlers::repair_activity_hack::anonymous_namespace{activity_handlers.cpp}::get_fake_tool(), get_known_connections(), getabs(), getglobal(), Character::global_square_location(), game::grabbed_furn_move(), grow_plant(), npc::guard_current_pos(), Character::knows_trap(), game::place_player(), game::place_vehicle_nearby(), iexamine::plant_seed(), game::pre_print_all_tile_info(), sounds::process_sounds(), zone_manager::rotate_zones(), target_ui::set_last_target(), shoot(), spawn_monsters_submap_group(), ter_set(), translate_radius(), update_suspension_cache(), use_charges_from_furn(), iexamine::use_furn_fake_item(), vertical_move_destination(), and game::zones_manager().

◆ getabs() [2/2]

point map::getabs ( point p ) const

inline

Definition at line 1611 of file map.h.

                                      {
            return getabs( tripoint( p, abs_sub.z ) ).xy();
        }

References abs_sub, getabs(), tripoint::xy(), and tripoint::z.

◆ getglobal()

tripoint_abs_ms map::getglobal ( const tripoint & p ) const

Definition at line 8412 of file map.cpp.

{
    return tripoint_abs_ms( getabs( p ) );
}

References getabs().

◆ getlocal() [1/3]

tripoint map::getlocal ( const tripoint & p ) const

Inverse of getabs.

Definition at line 8417 of file map.cpp.

{
    return p - sm_to_ms_copy( abs_sub.xy() );
}

References abs_sub, sm_to_ms_copy(), and tripoint::xy().

Referenced by grid_furn_transform_queue::apply(), basecamp_action_components::consume_components(), deregister_vehicle_zone(), construct::done_digormine_stair(), construct::done_mine_upstair(), game::find_or_make_stairs(), basecamp::form_crafting_inventory(), inventory::form_from_zone(), getlocal(), Character::has_destination_activity(), inbounds(), map_cursor::operator tripoint(), activity_handlers::pickaxe_do_turn(), teleporter_list::place_avatar_overmap(), basecamp::place_results(), game::place_vehicle_nearby(), target_ui::recalc_aim_turning_penalty(), rotate(), zone_manager::rotate_zones(), debug_menu::spawn_nested_mapgen(), target_ui::try_reacquire_target(), update_suspension_cache(), veh_at(), vertical_move_destination(), and game::zones_manager().

◆ getlocal() [2/3]

tripoint map::getlocal ( const tripoint_abs_ms & p ) const

Definition at line 8422 of file map.cpp.

{
    // TODO: fix point types
    return getlocal( p.raw() );
}

References getlocal(), and coords::coord_point< Point, Origin, Scale >::raw().

◆ getlocal() [3/3]

point map::getlocal ( point p ) const

inline

Definition at line 1619 of file map.h.

                                        {
            return getlocal( tripoint( p, abs_sub.z ) ).xy();
        }

References abs_sub, getlocal(), tripoint::xy(), and tripoint::z.

◆ getmapsize()

int map::getmapsize ( ) const

inline

Definition at line 1637 of file map.h.

                               {
            return my_MAPSIZE;
        }

References my_MAPSIZE.

Referenced by distribution_grid_tracker::load(), and points_in_range().

◆ getsubmap()

submap * map::getsubmap ( size_t grididx ) const

private

Get the submap pointer with given index in grid, the index must be valid!

Definition at line 8438 of file map.cpp.

{
    if( grididx >= grid.size() ) {
        debugmsg( "Tried to access invalid grid index %d. Grid size: %d", grididx, grid.size() );
        return nullptr;
    }
    return grid[grididx];
}

References debugmsg, and grid.

Referenced by generate(), get_submap_at_grid(), and saven().

◆ graffiti_at()

const std::string & map::graffiti_at ( const tripoint & p ) const

Definition at line 7969 of file map.cpp.

{
    if( !inbounds( p ) ) {
        static const std::string empty_string;
        return empty_string;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    return current_submap->get_graffiti( l );
}

References submap::get_graffiti(), get_submap_at(), and inbounds().

Referenced by game::place_player(), and game::print_graffiti_info().

◆ grow_plant()

void map::grow_plant ( const tripoint & p )

protected

Try to grow a harvestable plant to the next stage(s).

Definition at line 7292 of file map.cpp.

{
    const auto &furn = this->furn( p ).obj();
    if( !furn.has_flag( "PLANT" ) ) {
        return;
    }
    // Can't use item_stack::only_item() since there might be fertilizer
    map_stack items = i_at( p );
    map_stack::iterator seed = std::find_if( items.begin(), items.end(), []( const item & it ) {
        return it.is_seed();
    } );
 
    if( seed == items.end() ) {
        // No seed there anymore, we don't know what kind of plant it was.
        // TODO: Fix point types
        const oter_id ot = overmap_buffer.ter( project_to<coords::omt>( tripoint_abs_ms( getabs( p ) ) ) );
        dbg( DL::Error ) << "a planted item at " << p
                         << " (within overmap terrain " << ot.id().str() << ") has no seed data";
        i_clear( p );
        furn_set( p, f_null );
        return;
    }
    const time_duration plantEpoch = seed->get_plant_epoch();
    if( seed->age() >= plantEpoch * furn.plant->growth_multiplier &&
        !furn.has_flag( "GROWTH_HARVEST" ) ) {
        if( seed->age() < plantEpoch * 2 ) {
            if( has_flag_furn( "GROWTH_SEEDLING", p ) ) {
                return;
            }
 
            // Remove fertilizer if any
            map_stack::iterator fertilizer = std::find_if( items.begin(), items.end(), []( const item & it ) {
                return it.has_flag( "FERTILIZER" );
            } );
            if( fertilizer != items.end() ) {
                items.erase( fertilizer );
            }
 
            rotten_item_spawn( *seed, p );
            furn_set( p, furn_str_id( furn.plant->transform ) );
        } else if( seed->age() < plantEpoch * 3 * furn.plant->growth_multiplier ) {
            if( has_flag_furn( "GROWTH_MATURE", p ) ) {
                return;
            }
 
            // Remove fertilizer if any
            map_stack::iterator fertilizer = std::find_if( items.begin(), items.end(), []( const item & it ) {
                return it.has_flag( "FERTILIZER" );
            } );
            if( fertilizer != items.end() ) {
                items.erase( fertilizer );
            }
 
            rotten_item_spawn( *seed, p );
            //You've skipped the seedling stage so roll monsters twice
            if( !has_flag_furn( "GROWTH_SEEDLING", p ) ) {
                rotten_item_spawn( *seed, p );
            }
            furn_set( p, furn_str_id( furn.plant->transform ) );
        } else {
            //You've skipped two stages so roll monsters two times
            if( has_flag_furn( "GROWTH_SEEDLING", p ) ) {
                rotten_item_spawn( *seed, p );
                rotten_item_spawn( *seed, p );
                //One stage change
            } else if( has_flag_furn( "GROWTH_MATURE", p ) ) {
                rotten_item_spawn( *seed, p );
                //Goes from seed to harvest in one check
            } else {
                rotten_item_spawn( *seed, p );
                rotten_item_spawn( *seed, p );
                rotten_item_spawn( *seed, p );
            }
            furn_set( p, furn_str_id( furn.plant->transform ) );
        }
    }
}

References item_stack::begin(), dbg, item_stack::end(), map_stack::erase(), Error, f_null, furn(), furn_set(), getabs(), has_flag_furn(), i_at(), i_clear(), int_id< T >::id(), int_id< T >::obj(), overmap_buffer, rotten_item_spawn(), iuse::seed(), string_id< T >::str(), and overmapbuffer::ter().

Referenced by actualize().

◆ has_adjacent_furniture_with()

bool map::has_adjacent_furniture_with	(	const tripoint &	p,
		const std::function< bool(const furn_t &)> &	filter
	)

Returns true if there is furniture for which filter returns true in a 1 tile radius of p.

Pass return_true<furn_t> to detect all adjacent furniture.

Parameters

p	the location to check at
filter	what to filter the furniture by.

Definition at line 2804 of file map.cpp.

{
    for( const tripoint &adj : points_in_radius( p, 1 ) ) {
        if( has_furn( adj ) && filter( furn( adj ).obj() ) ) {
            return true;
        }
    }
 
    return false;
}

References furn(), has_furn(), and points_in_radius().

◆ has_field_at()

bool map::has_field_at	(	const tripoint &	p,
		bool	check_bounds = `true`
	)

Returns: true if there might be a field at p; false there's no fields at p

Definition at line 5507 of file map.cpp.

{
    const tripoint sm = ms_to_sm_copy( p );
    return ( !check_bounds || inbounds( p ) ) && get_cache( p.z ).field_cache[sm.x + sm.y * MAPSIZE];
}

References level_cache::field_cache, get_cache(), inbounds(), MAPSIZE, ms_to_sm_copy(), coords::sm, and tripoint::z.

Referenced by get_field().

◆ has_flag() [1/4]

bool map::has_flag	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2375 of file map.cpp.

{
    return has_flag_ter_or_furn( flag, p ); // Does bound checking
}

References has_flag_ter_or_furn().

Referenced by accessible_items(), add_item(), add_item_or_charges(), bash(), bash_ter_furn(), bash_ter_success(), start_location::burn(), game::butcher(), can_put_items_ter_furn(), climb_difficulty(), close_door(), doors::close_door(), collapse_at(), collapse_check(), displace_water(), dont_draw_lower_floor(), draw_lab(), drop_everything(), game::examine(), features(), find_furnitures_or_vparts_with_flag_in_radius(), game::find_or_make_stairs(), flammable_items_at(), game::fling_creature(), game::forced_door_closing(), game::get_dangerous_tile(), game::get_fishable_locations(), game::grabbed_furn_move(), has_flag(), has_nearby_chair(), has_nearby_table(), hit_with_fire(), is_divable(), game::is_empty(), is_flammable(), is_water_shallow_current(), game::knockback(), mop_spills(), avatar_action::move(), move_vehicle(), game::moving_vehicle_dismount(), MapExtras::mx_minefield(), item::on_drop(), open_door(), game::place_player(), game::print_fields_info(), game::print_items_info(), process_fields_in_submap(), propagate_field(), propagate_suspension_check(), avatar_action::ramp_move(), rate_location(), route(), shoot(), spawn_an_item(), spawn_items(), fungal_effects::spread_fungus(), fungal_effects::spread_fungus_one_tile(), avatar_action::swim(), game::update_stair_monsters(), use_charges_from_furn(), game::use_computer(), game::vertical_move(), vertical_move_destination(), game::walk_move(), and water_from().

◆ has_flag() [2/4]

bool map::has_flag	(	const std::string &	flag,
		point	p
	)		const

inline

Definition at line 904 of file map.h.

                                                              {
            return has_flag( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag(), and tripoint::z.

◆ has_flag() [3/4]

bool map::has_flag	(	ter_bitflags	flag,
		const tripoint &	p
	)		const

Definition at line 2418 of file map.cpp.

{
    return has_flag_ter_or_furn( flag, p ); // Does bound checking
}

References has_flag_ter_or_furn().

◆ has_flag() [4/4]

bool map::has_flag	(	ter_bitflags	flag,
		point	p
	)		const

inline

Definition at line 939 of file map.h.

                                                          {
            return has_flag( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag(), and tripoint::z.

◆ has_flag_furn() [1/4]

bool map::has_flag_furn	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2399 of file map.cpp.

{
    return furn( p ).obj().has_flag( flag );
}

References furn(), map_data_common_t::has_flag(), and int_id< T >::obj().

Referenced by bash_furn_success(), draw_lab(), find_furnitures_with_flag_in_radius(), find_valid_teleporters_omt(), grow_plant(), has_flag_furn(), has_flag_furn_or_vpart(), temperature_flag_at_point(), and rot::temperature_flag_for_location().

◆ has_flag_furn() [2/4]

bool map::has_flag_furn	(	const std::string &	flag,
		point	p
	)		const

inline

Definition at line 924 of file map.h.

                                                                   {
            return has_flag_furn( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_furn(), and tripoint::z.

◆ has_flag_furn() [3/4]

bool map::has_flag_furn	(	ter_bitflags	flag,
		const tripoint &	p
	)		const

Definition at line 2428 of file map.cpp.

{
    return furn( p ).obj().has_flag( flag );
}

References furn(), map_data_common_t::has_flag(), and int_id< T >::obj().

◆ has_flag_furn() [4/4]

bool map::has_flag_furn	(	ter_bitflags	flag,
		point	p
	)		const

inline

Definition at line 949 of file map.h.

                                                               {
            return has_flag_furn( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_furn(), and tripoint::z.

◆ has_flag_furn_or_vpart()

bool map::has_flag_furn_or_vpart	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2439 of file map.cpp.

{
    return has_flag_furn( flag, p ) || has_flag_vpart( flag, p );
}

References has_flag_furn(), and has_flag_vpart().

Referenced by find_furnitures_or_vparts_with_flag_in_radius().

◆ has_flag_ter() [1/4]

bool map::has_flag_ter	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2394 of file map.cpp.

{
    return ter( p ).obj().has_flag( flag );
}

References map_data_common_t::has_flag(), int_id< T >::obj(), and ter().

Referenced by add_vehicle_to_map(), jmapgen_terrain::apply(), bash_ter_success(), start_location::burn(), draw_lab(), find_potential_computer_point(), has_flag_ter(), is_last_ter_wall(), fungal_effects::marlossify(), MapExtras::mx_clearcut(), MapExtras::mx_grove(), MapExtras::mx_portal(), MapExtras::mx_shrubbery(), MapExtras::mx_spider(), obstacle_coverage(), game::place_player(), character_funcs::rate_sleep_spot(), fungal_effects::spread_fungus(), fungal_effects::spread_fungus_one_tile(), and game::walk_move().

◆ has_flag_ter() [2/4]

bool map::has_flag_ter	(	const std::string &	flag,
		point	p
	)		const

inline

Definition at line 919 of file map.h.

                                                                  {
            return has_flag_ter( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_ter(), and tripoint::z.

◆ has_flag_ter() [3/4]

bool map::has_flag_ter	(	ter_bitflags	flag,
		const tripoint &	p
	)		const

Definition at line 2423 of file map.cpp.

{
    return ter( p ).obj().has_flag( flag );
}

References map_data_common_t::has_flag(), int_id< T >::obj(), and ter().

◆ has_flag_ter() [4/4]

bool map::has_flag_ter	(	ter_bitflags	flag,
		point	p
	)		const

inline

Definition at line 944 of file map.h.

                                                              {
            return has_flag_ter( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_ter(), and tripoint::z.

◆ has_flag_ter_or_furn() [1/4]

bool map::has_flag_ter_or_furn	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2404 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap && //FIXME: can be null during mapgen
           ( current_submap->get_ter( l ).obj().has_flag( flag ) ||
             current_submap->get_furn( l ).obj().has_flag( flag ) );
}

References submap::get_furn(), get_submap_at(), submap::get_ter(), map_data_common_t::has_flag(), inbounds(), and int_id< T >::obj().

Referenced by can_use_bipod(), could_see_items(), fill_funnels(), inventory::form_from_map(), ranged::gunmode_checks_weapon(), has_flag(), has_flag_ter_or_furn(), has_nearby_fire(), Character::is_deaf(), game::place_player(), vehicle_movement::scan_rails_from_veh_internal(), spawn_monsters_submap_group(), and game::walk_move().

◆ has_flag_ter_or_furn() [2/4]

bool map::has_flag_ter_or_furn	(	const std::string &	flag,
		point	p
	)		const

inline

Definition at line 933 of file map.h.

                                                                          {
            return has_flag_ter_or_furn( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_ter_or_furn(), and tripoint::z.

◆ has_flag_ter_or_furn() [3/4]

bool map::has_flag_ter_or_furn	(	ter_bitflags	flag,
		const tripoint &	p
	)		const

Definition at line 2444 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap && //FIXME: can be null during mapgen
           ( current_submap->get_ter( l ).obj().has_flag( flag ) ||
             current_submap->get_furn( l ).obj().has_flag( flag ) );
}

References submap::get_furn(), get_submap_at(), submap::get_ter(), map_data_common_t::has_flag(), inbounds(), and int_id< T >::obj().

◆ has_flag_ter_or_furn() [4/4]

bool map::has_flag_ter_or_furn	(	ter_bitflags	flag,
		point	p
	)		const

inline

Definition at line 954 of file map.h.

                                                                      {
            return has_flag_ter_or_furn( flag, tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_flag_ter_or_furn(), and tripoint::z.

◆ has_flag_vpart()

bool map::has_flag_vpart	(	const std::string &	flag,
		const tripoint &	p
	)		const

Definition at line 2433 of file map.cpp.

{
    const optional_vpart_position vp = veh_at( p );
    return static_cast<bool>( vp.part_with_feature( flag, true ) );
}

References optional_vpart_position::part_with_feature(), and veh_at().

Referenced by has_flag_furn_or_vpart().

◆ has_floor()

bool map::has_floor ( const tripoint & p ) const

Definition at line 2072 of file map.cpp.

{
    if( !zlevels || p.z < -OVERMAP_DEPTH + 1 || p.z > OVERMAP_HEIGHT ) {
        return true;
    }
 
    if( !inbounds( p ) ) {
        return true;
    }
 
    return get_cache_ref( p.z ).floor_cache[p.x][p.y];
}

References level_cache::floor_cache, get_cache_ref(), inbounds(), OVERMAP_DEPTH, OVERMAP_HEIGHT, tripoint::x, tripoint::y, tripoint::z, and zlevels.

Referenced by drop_everything(), drop_furniture(), drop_items(), floor_between(), game::grabbed_furn_move(), game::print_terrain_info(), ranged_target_size(), and spawn_monsters_submap_group().

◆ has_floor_or_support()

bool map::has_floor_or_support ( const tripoint & p ) const

Definition at line 2121 of file map.cpp.

{
    const tripoint below( p.xy(), p.z - 1 );
    return !valid_move( p, below, false, true );
}

References valid_move(), tripoint::xy(), and tripoint::z.

Referenced by game::print_terrain_info(), avatar_action::ramp_move(), reachable_flood_steps(), and game::vertical_move().

◆ has_furn() [1/2]

bool map::has_furn ( const tripoint & p ) const

Definition at line 1408 of file map.cpp.

{
    return furn( p ) != f_null;
}

References f_null, and furn().

Referenced by add_boardable(), bash_resistance(), bash_strength(), board_up(), game::examine(), game::extended_description(), inventory::form_from_map(), furn_is_supported(), get_changed_ids_from_update(), activity_handlers::repair_activity_hack::anonymous_namespace{activity_handlers.cpp}::get_fake_tool(), game::grabbed_furn_move(), has_adjacent_furniture_with(), has_furn(), is_bashable(), is_bashable_furn(), is_last_ter_wall(), talk_function::loot_building(), fungal_effects::marlossify(), map_stack::max_volume(), name(), use_charges(), iexamine::use_furn_fake_item(), game::vertical_move(), and game::walk_move().

◆ has_furn() [2/2]

bool map::has_furn ( point p ) const

inline

Definition at line 789 of file map.h.

                                       {
            return has_furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, has_furn(), and tripoint::z.

◆ has_graffiti_at()

bool map::has_graffiti_at ( const tripoint & p ) const

Definition at line 7980 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    return current_submap->has_graffiti( l );
}

References get_submap_at(), submap::has_graffiti(), and inbounds().

Referenced by editmap::draw_main_ui_overlay(), game::place_player(), and game::print_graffiti_info().

◆ has_items()

bool map::has_items ( const tripoint & p ) const

Checks for existence of items.

Faster than i_at(p).empty

Definition at line 4891 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return !current_submap->get_items( l ).empty();
}

References submap::get_items(), get_submap_at(), and inbounds().

Referenced by bash_items(), drop_furniture(), drop_items(), flammable_items_at(), inventory::form_from_map(), generate_lightmap(), game::place_player(), sees_some_items(), and smash_items().

◆ has_nearby_chair()

bool map::has_nearby_chair	(	const tripoint &	p,
		int	radius = `1`
	)

Check whether a chair or vehicle seat is nearby.

Definition at line 2843 of file map.cpp.

{
    for( const tripoint &pt : points_in_radius( p, radius ) ) {
        const optional_vpart_position vp = veh_at( pt );
        if( has_flag( "CAN_SIT", pt ) ) {
            return true;
        }
        if( vp && vp->vehicle().has_part( "SEAT" ) ) {
            return true;
        }
    }
    return false;
}

References has_flag(), points_in_radius(), and veh_at().

◆ has_nearby_fire()

bool map::has_nearby_fire	(	const tripoint &	p,
		int	radius = `1`
	)

Definition at line 2816 of file map.cpp.

{
    for( const tripoint &pt : points_in_radius( p, radius ) ) {
        if( get_field( pt, fd_fire ) != nullptr ) {
            return true;
        }
        if( has_flag_ter_or_furn( "USABLE_FIRE", pt ) ) {
            return true;
        }
    }
    return false;
}

References fd_fire, get_field(), has_flag_ter_or_furn(), and points_in_radius().

Referenced by inventory::form_from_map().

◆ has_nearby_table()

bool map::has_nearby_table	(	const tripoint &	p,
		int	radius = `1`
	)

Check whether a table/workbench/vehicle kitchen or other flat surface is nearby that could be used for crafting or eating.

Definition at line 2829 of file map.cpp.

{
    for( const tripoint &pt : points_in_radius( p, radius ) ) {
        const optional_vpart_position vp = veh_at( p );
        if( has_flag( "FLAT_SURF", pt ) ) {
            return true;
        }
        if( vp && ( vp->vehicle().has_part( "KITCHEN" ) || vp->vehicle().has_part( "FLAT_SURF" ) ) ) {
            return true;
        }
    }
    return false;
}

References has_flag(), points_in_radius(), and veh_at().

◆ has_zlevels()

bool map::has_zlevels ( ) const

inline

Definition at line 1640 of file map.h.

                                 {
            return zlevels;
        }

References zlevels.

Referenced by draw_critter_internal(), game::get_dangerous_tile(), overmapbuffer::get_npcs_near_player(), map_memory::get_submap(), game::load_npcs(), game::look_around(), game::perhaps_add_random_npc(), game::place_player(), game::place_player_overmap(), points_in_range(), map_memory::prepare_region(), game::print_terrain_info(), route(), game::shift_monsters(), game::update_map(), game::update_stair_monsters(), game::vertical_move(), vertical_move_destination(), and game::vertical_shift().

◆ hit_with_acid()

bool map::hit_with_acid ( const tripoint & p )

Definition at line 3928 of file map.cpp.

{
    if( passable( p ) ) {
        return false;    // Didn't hit the tile!
    }
    const ter_id t = ter( p );
    if( t == t_wall_glass || t == t_wall_glass_alarm ||
        t == t_vat ) {
        ter_set( p, t_floor );
    } else if( t == t_door_c || t == t_door_locked || t == t_door_locked_peep ||
               t == t_door_locked_alarm ) {
        if( one_in( 3 ) ) {
            ter_set( p, t_door_b );
        }
    } else if( t == t_door_bar_c || t == t_door_bar_o || t == t_door_bar_locked || t == t_bars ||
               t == t_reb_cage ) {
        ter_set( p, t_floor );
        add_msg( m_warning, _( "The metal bars melt!" ) );
    } else if( t == t_door_b ) {
        if( one_in( 4 ) ) {
            ter_set( p, t_door_frame );
        } else {
            return false;
        }
    } else if( t == t_window || t == t_window_alarm || t == t_window_no_curtains ) {
        ter_set( p, t_window_empty );
    } else if( t == t_wax ) {
        ter_set( p, t_floor_wax );
    } else if( t == t_gas_pump || t == t_gas_pump_smashed ) {
        return false;
    } else if( t == t_card_science || t == t_card_military || t == t_card_industrial ) {
        ter_set( p, t_card_reader_broken );
    }
    return true;
}

References _, add_msg(), m_warning, one_in(), passable(), t_bars, t_card_industrial, t_card_military, t_card_reader_broken, t_card_science, t_door_b, t_door_bar_c, t_door_bar_locked, t_door_bar_o, t_door_c, t_door_frame, t_door_locked, t_door_locked_alarm, t_door_locked_peep, t_floor, t_floor_wax, t_gas_pump, t_gas_pump_smashed, t_reb_cage, t_vat, t_wall_glass, t_wall_glass_alarm, t_wax, t_window, t_window_alarm, t_window_empty, t_window_no_curtains, ter(), and ter_set().

◆ hit_with_fire()

bool map::hit_with_fire ( const tripoint & p )

Definition at line 3965 of file map.cpp.

{
    if( passable( p ) ) {
        return false;    // Didn't hit the tile!
    }
 
    // non passable but flammable terrain, set it on fire
    if( has_flag( "FLAMMABLE", p ) || has_flag( "FLAMMABLE_ASH", p ) ) {
        add_field( p, fd_fire, 3 );
    }
    return true;
}

References add_field(), fd_fire, has_flag(), and passable().

◆ hoist_submap_camp()

basecamp map::hoist_submap_camp ( const tripoint & p )

Definition at line 5713 of file map.cpp.

{
    basecamp *pcamp = get_submap_at( p )->camp.get();
    return pcamp ? *pcamp : basecamp();
}

References submap::camp, and get_submap_at().

Referenced by game::validate_camps().

◆ i_at() [1/2]

map_stack map::i_at ( const tripoint & p )

Definition at line 4210 of file map.cpp.

{
    if( !inbounds( p ) ) {
        nulitems.clear();
        return map_stack{ &nulitems, p, this };
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return map_stack{ &current_submap->get_items( l ), p, this };
}

References submap::get_items(), get_submap_at(), inbounds(), and nulitems.

Referenced by add_item_or_charges(), advanced_inventory_pane::add_items_from_area(), apply_faction_ownership(), bash_furn_success(), bash_items(), board_up(), MapExtras::burned_ground_parser(), game::butcher(), can_butcher_at(), advanced_inventory::change_square(), doors::close_door(), iuse::directional_antenna(), drop_furniture(), drop_items(), editmap::edit_itm(), game::examine(), farm_action(), talk_function::field_harvest(), fill_funnels(), game::find_nearby_items(), flammable_items_at(), game::forced_door_closing(), basecamp::form_crafting_inventory(), inventory::form_from_map(), free_volume(), furnname(), generate_lightmap(), advanced_inv_area::get_item_count(), game::grabbed_furn_move(), grow_plant(), liquid_handler::handle_liquid_from_ground(), i_at(), i_rem(), advanced_inventory_pane::load_settings(), talk_function::loot_building(), max_volume(), mop_spills(), MapExtras::mx_supplydrop(), om_harvest_itm(), npc::pick_up_item_map(), game::place_player(), game::print_items_info(), process_fields_in_submap(), process_items_in_submap(), produce_sap(), serialize_liquid_source(), smash_items(), fungal_effects::spread_fungus_one_tile(), game::start_hauling(), basecamp::start_relay_hide_site(), stored_volume(), tinder_at(), iexamine::toilet(), enzlave_actor::use(), use_amount_square(), use_charges(), use_charges_from_furn(), iexamine::use_furn_fake_item(), and iexamine::vending().

◆ i_at() [2/2]

map_stack map::i_at ( point p )

inline

Definition at line 1182 of file map.h.

                                  {
            return i_at( tripoint( p, abs_sub.z ) );
        }

References abs_sub, i_at(), and tripoint::z.

◆ i_clear() [1/2]

void map::i_clear ( const tripoint & p )

Definition at line 4248 of file map.cpp.

{
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    for( item &it : current_submap->get_items( l ) ) {
        // remove from the active items cache (if it isn't there does nothing)
        current_submap->active_items.remove( &it );
    }
    if( current_submap->active_items.empty() ) {
        submaps_with_active_items.erase( tripoint( abs_sub.x + p.x / SEEX, abs_sub.y + p.y / SEEY, p.z ) );
    }
 
    current_submap->set_lum( l, 0 );
    current_submap->get_items( l ).clear();
}

References abs_sub, submap::active_items, active_item_cache::empty(), submap::get_items(), get_submap_at(), active_item_cache::remove(), SEEX, SEEY, submap::set_lum(), submaps_with_active_items, tripoint::x, tripoint::y, and tripoint::z.

Referenced by jmapgen_terrain::apply(), board_up(), doors::close_door(), MapExtras::dead_vegetation_parser(), draw_lab(), drop_furniture(), drop_items(), farm_action(), talk_function::field_harvest(), game::grabbed_furn_move(), grow_plant(), i_clear(), mapgen_lake_shore(), om_harvest_itm(), and rad_scorch().

◆ i_clear() [2/2]

void map::i_clear ( point p )

inline

Definition at line 1187 of file map.h.

                                {
            i_clear( tripoint( p, abs_sub.z ) );
        }

References abs_sub, i_clear(), and tripoint::z.

◆ i_rem() [1/4]

void map::i_rem	(	const tripoint &	p,
		item *	it
	)

Definition at line 4239 of file map.cpp.

{
    map_stack map_items = i_at( p );
    map_stack::const_iterator iter = map_items.get_iterator_from_pointer( it );
    if( iter != map_items.end() ) {
        i_rem( p, iter );
    }
}

References item_stack::end(), item_stack::get_iterator_from_pointer(), i_at(), and i_rem().

◆ i_rem() [2/4]

map_stack::iterator map::i_rem	(	const tripoint &	p,
		map_stack::const_iterator	it
	)

Definition at line 4223 of file map.cpp.

{
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    // remove from the active items cache (if it isn't there does nothing)
    current_submap->active_items.remove( &*it );
    if( current_submap->active_items.empty() ) {
        submaps_with_active_items.erase( tripoint( abs_sub.x + p.x / SEEX, abs_sub.y + p.y / SEEY, p.z ) );
    }
 
    current_submap->update_lum_rem( l, *it );
 
    return current_submap->get_items( l ).erase( it );
}

References abs_sub, submap::active_items, active_item_cache::empty(), submap::get_items(), get_submap_at(), active_item_cache::remove(), SEEX, SEEY, submaps_with_active_items, submap::update_lum_rem(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by delete_cyborg_item(), map_stack::erase(), i_rem(), om_set_hide_site(), remove_rotten_items(), and smash_items().

◆ i_rem() [3/4]

map_stack::iterator map::i_rem	(	point	location,
		map_stack::const_iterator	it
	)

inline

Definition at line 1193 of file map.h.

                                                                              {
            return i_rem( tripoint( location, abs_sub.z ), it );
        }

References abs_sub, i_rem(), and tripoint::z.

◆ i_rem() [4/4]

void map::i_rem	(	point	p,
		item *	it
	)

inline

Definition at line 1197 of file map.h.

                                        {
            i_rem( tripoint( p, abs_sub.z ), it );
        }

References abs_sub, i_rem(), and tripoint::z.

◆ impassable() [1/2]

bool map::impassable ( const tripoint & p ) const

Definition at line 1860 of file map.cpp.

{
    return !passable( p );
}

References passable().

Referenced by add_splatter_trail(), add_vehicle_to_map(), bash_ter_furn(), destroy(), construct::done_digormine_stair(), game::find_or_make_stairs(), game::fling_creature(), game::grabbed_furn_move(), is_cornerfloor(), is_wall_adjacent(), game::knockback(), make_rubble(), mapgen_cavern(), game::monmove(), MapExtras::mx_drugdeal(), game::peek(), game::phasing_move(), place_spawns(), game::print_terrain_info(), process_fields_in_submap(), propagate_field(), ranged_target_size(), rate_location(), shoot(), and game::walk_move().

◆ impassable() [2/2]

bool map::impassable ( point p ) const

inline

Definition at line 566 of file map.h.

                                         {
            return !passable( p );
        }

References passable().

◆ impassable_ter_furn()

bool map::impassable_ter_furn ( const tripoint & p ) const

Definition at line 1893 of file map.cpp.

{
    return !passable_ter_furn( p );
}

References passable_ter_furn().

Referenced by climb_difficulty(), and displace_water().

◆ inbounds() [1/3]

bool map::inbounds ( const tripoint & p ) const

virtual

Reimplemented in tinymap.

Definition at line 7903 of file map.cpp.

{
    static constexpr tripoint map_boundary_min( 0, 0, -OVERMAP_DEPTH );
    static constexpr tripoint map_boundary_max( MAPSIZE_Y, MAPSIZE_X, OVERMAP_HEIGHT + 1 );
 
    static constexpr half_open_cuboid<tripoint> map_boundaries(
        map_boundary_min, map_boundary_max );
 
    return map_boundaries.contains( p );
}

References half_open_cuboid< Tripoint, >::contains(), MAPSIZE_X, MAPSIZE_Y, OVERMAP_DEPTH, and OVERMAP_HEIGHT.

Referenced by add_field(), add_item(), MapgenRemovePartHandler::add_item_or_charges(), add_item_or_charges(), add_vehicle(), add_vehicle_to_cache(), adjust_radiation(), ambient_light_at(), grid_furn_transform_queue::apply(), apply_light_source(), apply_vision_transparency_cache(), bash(), bash_rating(), build_sunlight_cache(), clear_path(), clear_vehicle_cache(), clear_vehicle_point_from_cache(), computer_at(), delete_graffiti(), delete_signage(), displace_vehicle(), do_vehicle_caching(), draw(), game::draw_look_around_cursor(), drawsq(), field_at(), furn(), furn_set(), generate_lightmap(), get_field(), get_known_connections(), get_radiation(), get_signage(), get_submap_at(), get_temperature(), graffiti_at(), has_field_at(), has_flag_ter_or_furn(), has_floor(), has_graffiti_at(), has_items(), i_at(), inbounds(), is_bashable(), is_outside(), light_at(), game::load_npcs(), maptile_at(), map_stack::max_volume(), move_cost(), move_cost_ter_furn(), obscured_by_vehicle_rotation(), obstructed_by_vehicle_rotation(), partial_con_at(), partial_con_remove(), partial_con_set(), pl_line_of_sight(), pl_sees(), game::print_all_tile_info(), remove_field(), remove_trap(), restore_vision_transparency_cache(), route(), npc::saw_player_recently(), sees(), set_graffiti(), set_radiation(), set_seen_cache_dirty(), set_signage(), set_temperature(), set_transparency_cache_dirty(), game::shift_monsters(), shift_traps(), shoot(), spawn_items(), ter(), ter_set(), tr_at(), trap_set(), update_suspension_cache(), valid_move(), and veh_at().

◆ inbounds() [2/3]

bool map::inbounds ( const tripoint_abs_ms & p ) const

Definition at line 7898 of file map.cpp.

{
    return inbounds( getlocal( p ) );
}

References getlocal(), and inbounds().

◆ inbounds() [3/3]

bool map::inbounds ( point p ) const

inline

Definition at line 1624 of file map.h.

                                       {
            return inbounds( tripoint( p, 0 ) );
        }

References inbounds().

◆ inbounds_z()

bool map::inbounds_z ( const int z ) const

inline

Definition at line 1628 of file map.h.

                                             {
            return z >= -OVERMAP_DEPTH && z <= OVERMAP_HEIGHT;
        }

References OVERMAP_DEPTH, and OVERMAP_HEIGHT.

Referenced by get_pathfinding_cache_ref(), invalidate_map_cache(), set_floor_cache_dirty(), set_outside_cache_dirty(), set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_suspension_cache_dirty(), set_transparency_cache_dirty(), and game::vertical_notes().

◆ invalidate_map_cache()

void map::invalidate_map_cache ( const int zlev )

Definition at line 8970 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        level_cache &ch = get_cache( zlev );
        ch.floor_cache_dirty = true;
        ch.transparency_cache_dirty.set();
        ch.seen_cache_dirty = true;
        ch.outside_cache_dirty = true;
        ch.suspension_cache_dirty = true;
    }
}

References level_cache::floor_cache_dirty, get_cache(), inbounds_z(), level_cache::outside_cache_dirty, level_cache::seen_cache_dirty, level_cache::suspension_cache_dirty, and level_cache::transparency_cache_dirty.

Referenced by debug_menu::debug(), game::look_around(), game::peek(), Character::perform_install(), start_location::place_player(), aim_activity_actor::restore_view(), target_ui::set_view_offset(), game::start_game(), game::update_map(), vehicle::use_bike_rack(), and game::vertical_move().

◆ invalidate_max_populated_zlev()

void map::invalidate_max_populated_zlev ( int zlev )

private

Conditionally invalidates max_pupulated_zlev cache if the submap uniformity change occurs above current max_pupulated_zlev value.

Parameters

zlev	zlevel where uniformity change occured

Definition at line 9176 of file map.cpp.

{
    if( max_populated_zlev && max_populated_zlev->second < zlev ) {
        max_populated_zlev->second = zlev;
    }
}

References max_populated_zlev.

Referenced by add_field(), add_item(), add_vehicle(), displace_vehicle(), furn_set(), shift_vehicle_z(), and ter_set().

◆ is_bashable() [1/2]

bool map::is_bashable	(	const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.

Definition at line 2507 of file map.cpp.

{
    if( !inbounds( p ) ) {
        dbg( DL::Warn ) << "Looking for out-of-bounds is_bashable at " << p;
        return false;
    }
 
    if( veh_at( p ).obstacle_at_part() ) {
        return true;
    }
 
    if( has_furn( p ) && furn( p ).obj().bash.str_max != -1 ) {
        return true;
    }
 
    const auto &ter_bash = ter( p ).obj().bash;
    return ter_bash.str_max != -1 && ( !ter_bash.bash_below || allow_floor );
}

References bash(), map_data_common_t::bash, dbg, furn(), has_furn(), inbounds(), int_id< T >::obj(), map_bash_info::str_max, ter(), veh_at(), and Warn.

Referenced by MapExtras::burned_ground_parser(), features(), game::fling_creature(), is_bashable(), and MapExtras::mx_helicopter().

◆ is_bashable() [2/2]

bool map::is_bashable ( point p ) const

inline

Definition at line 961 of file map.h.

                                          {
            return is_bashable( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_bashable(), and tripoint::z.

◆ is_bashable_furn() [1/2]

bool map::is_bashable_furn ( const tripoint & p ) const

Returns true if the furniture at p is bashable.

Definition at line 2533 of file map.cpp.

{
    return has_furn( p ) && furn( p ).obj().bash.str_max != -1;
}

References map_data_common_t::bash, furn(), has_furn(), int_id< T >::obj(), and map_bash_info::str_max.

Referenced by is_bashable_furn(), is_bashable_ter_furn(), and make_rubble().

◆ is_bashable_furn() [2/2]

bool map::is_bashable_furn ( point p ) const

inline

Definition at line 971 of file map.h.

                                               {
            return is_bashable_furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_bashable_furn(), and tripoint::z.

◆ is_bashable_ter() [1/2]

bool map::is_bashable_ter	(	const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns true if the terrain at p is bashable.

Definition at line 2526 of file map.cpp.

{
    const auto &ter_bash = ter( p ).obj().bash;
    return ter_bash.str_max != -1 && ( ( !ter_bash.bash_below &&
                                         !ter( p ).obj().has_flag( "VEH_TREAT_AS_BASH_BELOW" ) ) || allow_floor );
}

References map_data_common_t::bash, map_data_common_t::has_flag(), int_id< T >::obj(), map_bash_info::str_max, and ter().

Referenced by is_bashable_ter(), is_bashable_ter_furn(), and make_rubble().

◆ is_bashable_ter() [2/2]

bool map::is_bashable_ter ( point p ) const

inline

Definition at line 966 of file map.h.

                                              {
            return is_bashable_ter( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_bashable_ter(), and tripoint::z.

◆ is_bashable_ter_furn() [1/2]

bool map::is_bashable_ter_furn	(	const tripoint &	p,
		bool	allow_floor = `false`
	)		const

Returns true if the furniture or terrain at p is bashable.

Definition at line 2538 of file map.cpp.

{
    return is_bashable_furn( p ) || is_bashable_ter( p, allow_floor );
}

References is_bashable_furn(), and is_bashable_ter().

Referenced by is_bashable_ter_furn().

◆ is_bashable_ter_furn() [2/2]

bool map::is_bashable_ter_furn ( point p ) const

inline

Definition at line 976 of file map.h.

                                                   {
            return is_bashable_ter_furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_bashable_ter_furn(), and tripoint::z.

◆ is_cornerfloor()

bool map::is_cornerfloor ( const tripoint & p ) const

Definition at line 9113 of file map.cpp.

{
    if( impassable( p ) ) {
        return false;
    }
    std::set<tripoint> impassable_adjacent;
    for( const tripoint &pt : points_in_radius( p, 1 ) ) {
        if( impassable( pt ) ) {
            impassable_adjacent.insert( pt );
        }
    }
    if( !impassable_adjacent.empty() ) {
        //to check if a floor is a corner we first search if any of its diagonal adjacent points is impassable
        std::set< tripoint> diagonals = { p + tripoint_north_east, p + tripoint_north_west, p + tripoint_south_east, p + tripoint_south_west };
        for( const tripoint &impassable_diagonal : diagonals ) {
            if( impassable_adjacent.count( impassable_diagonal ) != 0 ) {
                //for every impassable diagonal found, we check if that diagonal terrain has at least two impassable neighbors that also neighbor point p
                int f = 0;
                for( const tripoint &l : points_in_radius( impassable_diagonal, 1 ) ) {
                    if( impassable_adjacent.count( l ) != 0 ) {
                        f++;
                    }
                    if( f > 2 ) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

References impassable(), points_in_radius(), tripoint_north_east, tripoint_north_west, tripoint_south_east, and tripoint_south_west.

◆ is_divable() [1/2]

bool map::is_divable ( const tripoint & p ) const

Returns whether or not the terrain at the given location can be dived into (by monsters that can swim or are aquatic or non-breathing).

Parameters

p	The coordinate to look at.

Returns: true if the terrain can be dived into; false if not.

Definition at line 2621 of file map.cpp.

{
    return has_flag( "SWIMMABLE", p ) && has_flag( TFLAG_DEEP_WATER, p );
}

References has_flag(), and TFLAG_DEEP_WATER.

Referenced by enchantment::is_active(), and is_divable().

◆ is_divable() [2/2]

bool map::is_divable ( point p ) const

inline

Definition at line 1019 of file map.h.

                                         {
            return is_divable( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_divable(), and tripoint::z.

◆ is_flammable()

bool map::is_flammable ( const tripoint & p )

Returns true if there is a flammable item or field or the furn/terrain is flammable at p.

Definition at line 2705 of file map.cpp.

{
    if( flammable_items_at( p ) ) {
        return true;
    }
 
    if( has_flag( "FLAMMABLE", p ) ) {
        return true;
    }
 
    if( has_flag( "FLAMMABLE_ASH", p ) ) {
        return true;
    }
 
    if( get_field_intensity( p, fd_web ) > 0 ) {
        return true;
    }
 
    return false;
}

References fd_web, flammable_items_at(), get_field_intensity(), and has_flag().

◆ is_harvestable()

bool map::is_harvestable ( const tripoint & pos ) const

Returns true if point at pos is harvestable right now, with no extra tools.

Definition at line 1695 of file map.cpp.

{
    const auto &harvest_here = get_harvest( pos );
    return !harvest_here.is_null() && !harvest_here->empty();
}

References get_harvest(), and wrapped_vehicle::pos.

◆ is_last_ter_wall()

bool map::is_last_ter_wall	(	bool	no_furn,
		point	p,
		point	max,
		direction	dir
	)		const

Check if the last terrain is wall in direction NORTH, SOUTH, WEST or EAST.

Parameters

no_furn	if true, the function will stop and return false if it encounters a furniture
p	starting coordinates of check
max	ending coordinates of check
dir	Direction of check

Returns: true if from x to xmax or y to ymax depending on direction all terrain is floor and the last terrain is a wall

Definition at line 2636 of file map.cpp.

{
    point mov;
    switch( dir ) {
        case direction::NORTH:
            mov.y = -1;
            break;
        case direction::SOUTH:
            mov.y = 1;
            break;
        case direction::WEST:
            mov.x = -1;
            break;
        case direction::EAST:
            mov.x = 1;
            break;
        default:
            break;
    }
    point p2( p );
    bool result = true;
    bool loop = true;
    while( ( loop ) && ( ( dir == direction::NORTH && p2.y >= 0 ) ||
                         ( dir == direction::SOUTH && p2.y < max.y ) ||
                         ( dir == direction::WEST  && p2.x >= 0 ) ||
                         ( dir == direction::EAST  && p2.x < max.x ) ) ) {
        if( no_furn && has_furn( p2 ) ) {
            loop = false;
            result = false;
        } else if( !has_flag_ter( "FLAT", p2 ) ) {
            loop = false;
            if( !has_flag_ter( "WALL", p2 ) ) {
                result = false;
            }
        }
        p2.x += mov.x;
        p2.y += mov.y;
    }
    return result;
}

References EAST, has_flag_ter(), has_furn(), NORTH, SOUTH, WEST, point::x, and point::y.

Referenced by find_potential_computer_point().

◆ is_outside() [1/2]

bool map::is_outside ( const tripoint & p ) const

Definition at line 2626 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return true;
    }
 
    const auto &outside_cache = get_cache_ref( p.z ).outside_cache;
    return outside_cache[p.x][p.y];
}

References get_cache_ref(), inbounds(), level_cache::outside_cache, tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_boardable(), board_up(), start_location::burn(), relic_funcs::check_recharge_reqs(), doors::close_door(), generate_weather_anim_frame(), game::handle_action(), weather::is_in_sunlight(), is_outside(), is_player_outside(), weather::is_sheltered(), avatar_action::move(), random_outdoor_tile(), rate_location(), route(), spread_gas(), and game::try_get_right_click_action().

◆ is_outside() [2/2]

bool map::is_outside ( point p ) const

inline

Definition at line 1009 of file map.h.

                                         {
            return is_outside( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_outside(), and tripoint::z.

◆ is_suspension_valid()

bool map::is_suspension_valid ( const tripoint & point )

Checks the four orientations in which a suspended tile could be valid, and returns if the tile is valid.

Definition at line 3025 of file map.cpp.

{
    if( ter( point + tripoint_east ) != t_open_air
        && ter( point + tripoint_west ) != t_open_air ) {
        return true;
    }
    if( ter( point + tripoint_south_east ) != t_open_air
        && ter( point + tripoint_north_west ) != t_open_air ) {
        return true;
    }
    if( ter( point + tripoint_south ) != t_open_air
        && ter( point + tripoint_north ) != t_open_air ) {
        return true;
    }
    if( ter( point + tripoint_north_east ) != t_open_air
        && ter( point + tripoint_south_west ) != t_open_air ) {
        return true;
    }
    return false;
}

References t_open_air, ter(), tripoint_east, tripoint_north, tripoint_north_east, tripoint_north_west, tripoint_south, tripoint_south_east, tripoint_south_west, and tripoint_west.

Referenced by collapse_invalid_suspension(), and update_suspension_cache().

◆ is_transparent()

bool map::is_transparent ( const tripoint & p ) const

Returns whether the tile at p is transparent(you can look past it).

Definition at line 691 of file lightmap.cpp.

{
    return light_transparency( p ) > LIGHT_TRANSPARENCY_SOLID;
}

References light_transparency(), and LIGHT_TRANSPARENCY_SOLID.

Referenced by get_known_connections(), and shoot().

◆ is_wall_adjacent()

bool map::is_wall_adjacent ( const tripoint & center ) const

Definition at line 1833 of file map.cpp.

{
    for( const tripoint &p : points_in_radius( center, 1 ) ) {
        if( p != center && impassable( p ) ) {
            return true;
        }
    }
    return false;
}

References center, impassable(), and points_in_radius().

Referenced by ma_requirements::is_valid_character().

◆ is_water_shallow_current() [1/2]

bool map::is_water_shallow_current ( const tripoint & p ) const

Definition at line 2616 of file map.cpp.

{
    return has_flag( "CURRENT", p ) && !has_flag( TFLAG_DEEP_WATER, p );
}

References has_flag(), and TFLAG_DEEP_WATER.

Referenced by is_water_shallow_current().

◆ is_water_shallow_current() [2/2]

bool map::is_water_shallow_current ( point p ) const

inline

Definition at line 1023 of file map.h.

                                                       {
            return is_water_shallow_current( tripoint( p, abs_sub.z ) );
        }

References abs_sub, is_water_shallow_current(), and tripoint::z.

◆ light_at()

lit_level map::light_at ( const tripoint & p ) const

Definition at line 657 of file lightmap.cpp.

{
    if( !inbounds( p ) ) {
        return lit_level::DARK;    // Out of bounds
    }
 
    const auto &map_cache = get_cache_ref( p.z );
    const auto &lm = map_cache.lm;
    const auto &sm = map_cache.sm;
    if( sm[p.x][p.y] >= LIGHT_SOURCE_BRIGHT ) {
        return lit_level::BRIGHT;
    }
 
    const float max_light = lm[p.x][p.y].max();
    if( max_light >= LIGHT_AMBIENT_LIT ) {
        return lit_level::LIT;
    }
 
    if( max_light >= LIGHT_AMBIENT_LOW ) {
        return lit_level::LOW;
    }
 
    return lit_level::DARK;
}

References BRIGHT, DARK, get_cache_ref(), inbounds(), LIGHT_AMBIENT_LIT, LIGHT_AMBIENT_LOW, LIGHT_SOURCE_BRIGHT, LIT, LOW, coords::sm, tripoint::x, tripoint::y, and tripoint::z.

◆ light_transparency()

float map::light_transparency ( const tripoint & p ) const

Definition at line 696 of file lightmap.cpp.

{
    return get_cache_ref( p.z ).transparency_cache[p.x][p.y];
}

References get_cache_ref(), level_cache::transparency_cache, tripoint::x, tripoint::y, and tripoint::z.

Referenced by generate_lightmap(), and is_transparent().

◆ load() [1/2]

void map::load	(	const tripoint &	w,
		bool	update_vehicles,
		bool	pump_events = `false`
	)

Load submaps into grid.

This might create new submaps if the mapbuffer can not deliver the requested submap (as it does not exist on disc). This must be called before the map can be used at all!

Parameters

w	global coordinates of the submap at grid[0]. This is in submap coordinates.
update_vehicles	If true, add vehicles to the vehicle cache.
pump_events	If true, handle window events during loading. If you set this to true, do ensure that the map is not accessed before this function returns (for example, UIs that draw the map should be disabled).

Definition at line 6750 of file map.cpp.

{
    for( auto &traps : traplocs ) {
        traps.clear();
    }
    field_furn_locs.clear();
    submaps_with_active_items.clear();
    set_abs_sub( w );
    for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
        for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
            loadn( point( gridx, gridy ), update_vehicle );
            if( pump_events ) {
                inp_mngr.pump_events();
            }
        }
    }
    reset_vehicle_cache( );
}

References field_furn_locs, inp_mngr, loadn(), my_MAPSIZE, input_manager::pump_events(), reset_vehicle_cache(), set_abs_sub(), submaps_with_active_items, and traplocs.

◆ load() [2/2]

void map::load	(	const tripoint_abs_sm &	w,
		bool	update_vehicles,
		bool	pump_events = `false`
	)

Definition at line 6769 of file map.cpp.

{
    // TODO: fix point types
    load( w.raw(), update_vehicle, pump_events );
}

References load(), and coords::coord_point< Point, Origin, Scale >::raw().

◆ loadn() [1/2]

void map::loadn	(	const tripoint &	grid,
		bool	update_vehicles
	)

protected

Definition at line 7132 of file map.cpp.

{
    // Cache empty overmap types
    static const oter_id rock( "empty_rock" );
    static const oter_id air( "open_air" );
 
    const tripoint grid_abs_sub = abs_sub.xy() + grid;
    const size_t gridn = get_nonant( grid );
 
    const int old_abs_z = abs_sub.z; // Ugly, but necessary at the moment
    abs_sub.z = grid.z;
 
    submap *tmpsub = MAPBUFFER.lookup_submap( grid_abs_sub );
    if( tmpsub == nullptr ) {
        // It doesn't exist; we must generate it!
        dbg( DL::Info ) << "map::loadn: Missing mapbuffer data.  Regenerating.";
 
        // Each overmap square is two nonants; to prevent overlap, generate only at
        //  squares divisible by 2.
        // TODO: fix point types
        const tripoint_abs_omt grid_abs_omt( sm_to_omt_copy( grid_abs_sub ) );
        const tripoint grid_abs_sub_rounded = omt_to_sm_copy( grid_abs_omt.raw() );
 
        const oter_id terrain_type = overmap_buffer.ter( grid_abs_omt );
 
        // Short-circuit if the map tile is uniform
        // TODO: Replace with json mapgen functions.
        if( terrain_type == air ) {
            generate_uniform( grid_abs_sub_rounded, t_open_air );
        } else if( terrain_type == rock ) {
            generate_uniform( grid_abs_sub_rounded, t_rock );
        } else {
            tinymap tmp_map;
            tmp_map.generate( grid_abs_sub_rounded, calendar::turn );
        }
 
        // This is the same call to MAPBUFFER as above!
        tmpsub = MAPBUFFER.lookup_submap( grid_abs_sub );
        if( tmpsub == nullptr ) {
            debugmsg( "failed to generate a submap at %s", grid_abs_sub.to_string() );
            return;
        }
    }
 
    // New submap changes the content of the map and all caches must be recalculated
    set_transparency_cache_dirty( grid.z );
    set_seen_cache_dirty( grid.z );
    set_outside_cache_dirty( grid.z );
    set_floor_cache_dirty( grid.z );
    set_pathfinding_cache_dirty( grid.z );
    set_suspension_cache_dirty( grid.z );
    setsubmap( gridn, tmpsub );
    if( !tmpsub->active_items.empty() ) {
        submaps_with_active_items.emplace( grid_abs_sub );
    }
    if( tmpsub->field_count > 0 ) {
        get_cache( grid.z ).field_cache.set( grid.x + grid.y * MAPSIZE );
    }
    // Destroy bugged no-part vehicles
    auto &veh_vec = tmpsub->vehicles;
    for( auto iter = veh_vec.begin(); iter != veh_vec.end(); ) {
        vehicle *veh = iter->get();
        if( veh->part_count() > 0 ) {
            // Always fix submap coordinates for easier Z-level-related operations
            veh->sm_pos = grid;
            veh->attach();
            iter++;
        } else {
            reset_vehicle_cache();
            if( veh->tracking_on ) {
                overmap_buffer.remove_vehicle( veh );
            }
            dirty_vehicle_list.erase( veh );
            iter = veh_vec.erase( iter );
        }
    }
 
    // Update vehicle data
    if( update_vehicles ) {
        auto &map_cache = get_cache( grid.z );
        for( const auto &veh : tmpsub->vehicles ) {
            // Only add if not tracking already.
            if( map_cache.vehicle_list.find( veh.get() ) == map_cache.vehicle_list.end() ) {
                map_cache.vehicle_list.insert( veh.get() );
                if( !veh->loot_zones.empty() ) {
                    map_cache.zone_vehicles.insert( veh.get() );
                }
                add_vehicle_to_cache( veh.get() );
            }
        }
    }
 
    actualize( grid );
 
    abs_sub.z = old_abs_z;
}

References abs_sub, submap::active_items, actualize(), add_vehicle_to_cache(), vehicle::attach(), dbg, debugmsg, dirty_vehicle_list, active_item_cache::empty(), level_cache::field_cache, submap::field_count, generate(), generate_uniform(), get_cache(), get_nonant(), grid, Info, mapbuffer::lookup_submap(), MAPBUFFER, MAPSIZE, omt_to_sm_copy(), overmap_buffer, vehicle::part_count(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::remove_vehicle(), reset_vehicle_cache(), set_floor_cache_dirty(), set_outside_cache_dirty(), set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_suspension_cache_dirty(), set_transparency_cache_dirty(), setsubmap(), vehicle::sm_pos, sm_to_omt_copy(), submaps_with_active_items, t_open_air, t_rock, overmapbuffer::ter(), tripoint::to_string(), vehicle::tracking_on, calendar::turn, submap::vehicles, tripoint::xy(), and tripoint::z.

Referenced by load(), loadn(), and shift().

◆ loadn() [2/2]

void map::loadn	(	point	grid,
		bool	update_vehicles
	)

inlineprotected

Definition at line 1678 of file map.h.

                                                       {
            if( zlevels ) {
                for( int gridz = -OVERMAP_DEPTH; gridz <= OVERMAP_HEIGHT; gridz++ ) {
                    loadn( tripoint( grid, gridz ), update_vehicles );
                }
 
                // Note: we want it in a separate loop! It is a post-load cleanup
                // Since we're adding roofs, we want it to go up (from lowest to highest)
                for( int gridz = -OVERMAP_DEPTH; gridz <= OVERMAP_HEIGHT; gridz++ ) {
                    add_roofs( tripoint( grid, gridz ) );
                }
            } else {
                loadn( tripoint( grid, abs_sub.z ), update_vehicles );
            }
        }

References abs_sub, add_roofs(), grid, loadn(), OVERMAP_DEPTH, OVERMAP_HEIGHT, tripoint::z, and zlevels.

◆ make_active()

void map::make_active ( item_location & loc )

Update an item's active status, for example when adding hot or perishable liquid to a container.

Definition at line 4547 of file map.cpp.

{
    item *target = loc.get_item();
 
    // Trust but verify, don't let stinking callers set items active when they shouldn't be.
    if( !target->needs_processing() ) {
        return;
    }
    point l;
    submap *const current_submap = get_submap_at( loc.position(), l );
    cata::colony<item> &item_stack = current_submap->get_items( l );
    cata::colony<item>::iterator iter = item_stack.get_iterator_from_pointer( target );
 
    if( current_submap->active_items.empty() ) {
        submaps_with_active_items.insert( tripoint( abs_sub.x + loc.position().x / SEEX,
                                          abs_sub.y + loc.position().y / SEEY, loc.position().z ) );
    }
    current_submap->active_items.add( *iter, l );
}

References abs_sub, submap::active_items, active_item_cache::add(), active_item_cache::empty(), item_location::get_item(), submap::get_items(), item_stack::get_iterator_from_pointer(), get_submap_at(), item::needs_processing(), item_location::position(), SEEX, SEEY, submaps_with_active_items, tripoint::x, tripoint::y, and tripoint::z.

◆ make_rubble() [1/3]

void map::make_rubble ( const tripoint & p )

inline

Definition at line 1004 of file map.h.

                                              {
            make_rubble( p, f_rubble, t_dirt, false );
        }

References f_rubble, make_rubble(), and t_dirt.

◆ make_rubble() [2/3]

void map::make_rubble	(	const tripoint &	p,
		const furn_id &	rubble_type
	)

inline

Definition at line 1001 of file map.h.

                                                                          {
            make_rubble( p, rubble_type, t_dirt, false );
        }

References make_rubble(), and t_dirt.

◆ make_rubble() [3/3]

void map::make_rubble	(	const tripoint &	p,
		const furn_id &	rubble_type,
		const ter_id &	floor_type,
		bool	overwrite = `false`
	)

Generates rubble at the given location, if overwrite is true it just writes on top of what currently exists floor_type is only used if there is a non-bashable wall at the location or with overwrite = true.

Definition at line 2592 of file map.cpp.

{
    if( overwrite ) {
        ter_set( p, floor_type );
        furn_set( p, rubble_type );
    } else {
        // First see if there is existing furniture to destroy
        if( is_bashable_furn( p ) ) {
            destroy_furn( p, true );
        }
        // Leave the terrain alone unless it interferes with furniture placement
        if( impassable( p ) && is_bashable_ter( p ) ) {
            destroy( p, true );
        }
        // Check again for new terrain after potential destruction
        if( impassable( p ) ) {
            ter_set( p, floor_type );
        }
 
        furn_set( p, rubble_type );
    }
}

References destroy(), destroy_furn(), furn_set(), impassable(), is_bashable_furn(), is_bashable_ter(), and ter_set().

Referenced by jmapgen_make_rubble::apply(), collapse_at(), draw_lab(), draw_mine(), make_rubble(), mapgen_crater(), MapExtras::mx_helicopter(), and MapExtras::mx_portal().

◆ maptile_at() [1/2]

maptile map::maptile_at ( const tripoint & p )

Definition at line 270 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return maptile( &null_submap, point_zero );
    }
 
    return maptile_at_internal( p );
}

References inbounds(), maptile_at_internal(), null_submap, and point_zero.

◆ maptile_at() [2/2]

maptile map::maptile_at ( const tripoint & p ) const

Definition at line 261 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return maptile( &null_submap, point_zero );
    }
 
    return maptile_at_internal( p );
}

References inbounds(), maptile_at_internal(), null_submap, and point_zero.

Referenced by editmap::draw_main_ui_overlay(), drawsq(), gas_can_spread_to(), get_wind_blockers(), maptile_has_bounds(), supports_above(), and valid_move().

◆ maptile_at_internal() [1/2]

maptile map::maptile_at_internal ( const tripoint & p )

private

Definition at line 287 of file map.cpp.

{
    point l;
    submap *const sm = get_submap_at( p, l );
 
    return maptile( sm, l );
}

References get_submap_at(), and coords::sm.

◆ maptile_at_internal() [2/2]

maptile map::maptile_at_internal ( const tripoint & p ) const

private

Definition at line 279 of file map.cpp.

{
    point l;
    submap *const sm = get_submap_at( p, l );
 
    return maptile( sm, l );
}

References get_submap_at(), and coords::sm.

Referenced by draw(), maptile_at(), maptile_has_bounds(), process_fields_in_submap(), route(), and spread_gas().

◆ maptile_has_bounds()

std::pair< tripoint, maptile > map::maptile_has_bounds	(	const tripoint &	p,
		bool	bounds_checked
	)

private

Definition at line 181 of file map_field.cpp.

{
    if( bounds_checked ) {
        // We know that the point is in bounds
        return {p, maptile_at_internal( p )};
    }
 
    return {p, maptile_at( p )};
}

References maptile_at(), and maptile_at_internal().

Referenced by get_neighbors().

◆ max_volume()

units::volume map::max_volume ( const tripoint & p )

Definition at line 4338 of file map.cpp.

{
    return i_at( p ).max_volume();
}

References i_at(), and map_stack::max_volume().

Referenced by advanced_inventory::print_items().

◆ mod_field_age()

time_duration map::mod_field_age	(	const tripoint &	p,
		const field_type_id &	type,
		const time_duration &	offset
	)

Increment/decrement age of field entry at point.

Returns: resulting age or -1_turns if not present (does not create a new field).

Definition at line 5449 of file map.cpp.

{
    return set_field_age( p, type, offset, true );
}

References set_field_age(), and type.

Referenced by game::process_artifact().

◆ mod_field_intensity()

int map::mod_field_intensity	(	const tripoint &	p,
		const field_type_id &	type,
		int	offset
	)

Increment/decrement intensity of field entry at point, creating if not present, removing if intensity becomes 0.

Returns: resulting intensity, or 0 for not present (either removed or not created at all).

Definition at line 5455 of file map.cpp.

{
    return set_field_intensity( p, type, offset, true );
}

References set_field_intensity(), and type.

Referenced by add_splatter(), and propagate_field().

◆ monster_in_field()

void map::monster_in_field ( monster & z )

protected

Definition at line 1632 of file map_field.cpp.

{
    if( z.digging() ) {
        // Digging monsters are immune to fields
        return;
    }
    if( veh_at( z.pos() ) ) {
        // FIXME: Immune when in a vehicle for now.
        return;
    }
    field &curfield = get_field( z.pos() );
 
    int dam = 0;
    // Iterate through all field effects on this tile.
    // Do not remove the field with remove_field, instead set it's intensity to 0. It will be removed
    // later by the field processing, which will also adjust field_count accordingly.
    for( auto &field_list_it : curfield ) {
        field_entry &cur = field_list_it.second;
        if( !cur.is_field_alive() ) {
            continue;
        }
        const field_type_id cur_field_type = cur.get_field_type();
        if( cur_field_type == fd_web ) {
            if( !z.has_flag( MF_WEBWALK ) ) {
                z.add_effect( effect_webbed, 1_turns, num_bp, cur.get_field_intensity() );
                cur.set_field_intensity( 0 );
            }
        }
        if( cur_field_type == fd_acid ) {
            if( !z.flies() ) {
                const int d = rng( cur.get_field_intensity(), cur.get_field_intensity() * 3 );
                z.deal_damage( nullptr, bodypart_id( "torso" ), damage_instance( DT_ACID, d ) );
                z.check_dead_state();
                if( d > 0 ) {
                    z.add_effect( effect_corroding, 1_turns * rng( d / 2, d * 2 ) );
                }
            }
 
        }
        if( cur_field_type == fd_sap ) {
            z.moves -= cur.get_field_intensity() * 5;
            cur.set_field_intensity( cur.get_field_intensity() - 1 );
        }
        if( cur_field_type == fd_sludge ) {
            if( !z.digs() && !z.flies() &&
                !z.has_flag( MF_SLUDGEPROOF ) ) {
                z.moves -= cur.get_field_intensity() * 300;
                cur.set_field_intensity( 0 );
            }
        }
        if( cur_field_type == fd_fire ) {
            // TODO: MATERIALS Use fire resistance
            if( z.has_flag( MF_FIREPROOF ) || z.has_flag( MF_FIREY ) ) {
                return;
            }
            // TODO: Replace the section below with proper json values
            if( z.made_of_any( Creature::cmat_flesh ) ) {
                dam += 3;
            }
            if( z.made_of( material_id( "veggy" ) ) ) {
                dam += 12;
            }
            if( z.made_of( LIQUID ) || z.made_of_any( Creature::cmat_flammable ) ) {
                dam += 20;
            }
            if( z.made_of_any( Creature::cmat_flameres ) ) {
                dam += -20;
            }
            if( z.flies() ) {
                dam -= 15;
            }
            dam -= z.get_armor_type( DT_HEAT, bodypart_id( "torso" ) );
 
            if( cur.get_field_intensity() == 1 ) {
                dam += rng( 2, 6 );
            } else if( cur.get_field_intensity() == 2 ) {
                dam += rng( 6, 12 );
                if( !z.flies() ) {
                    z.moves -= 20;
                    if( dam > 0 ) {
                        z.add_effect( effect_onfire, 1_turns * rng( dam / 2, dam * 2 ) );
                    }
                }
            } else if( cur.get_field_intensity() == 3 ) {
                dam += rng( 10, 20 );
                if( !z.flies() || one_in( 3 ) ) {
                    z.moves -= 40;
                    if( dam > 0 ) {
                        z.add_effect( effect_onfire, 1_turns * rng( dam / 2, dam * 2 ) );
                    }
                }
            }
        }
        if( cur_field_type == fd_smoke ) {
            if( !z.has_flag( MF_NO_BREATHE ) ) {
                if( cur.get_field_intensity() == 3 ) {
                    z.moves -= rng( 10, 20 );
                }
                // Plants suffer from smoke even worse
                if( z.made_of( material_id( "veggy" ) ) ) {
                    z.moves -= rng( 1, cur.get_field_intensity() * 12 );
                }
            }
 
        }
        if( cur_field_type == fd_tear_gas ) {
            if( z.made_of_any( Creature::cmat_fleshnveg ) && !z.has_flag( MF_NO_BREATHE ) ) {
                if( cur.get_field_intensity() == 3 ) {
                    z.add_effect( effect_stunned, rng( 1_minutes, 2_minutes ) );
                    dam += rng( 4, 10 );
                } else if( cur.get_field_intensity() == 2 ) {
                    z.add_effect( effect_stunned, rng( 5_turns, 10_turns ) );
                    dam += rng( 2, 5 );
                } else {
                    z.add_effect( effect_stunned, rng( 1_turns, 5_turns ) );
                }
                if( z.made_of( material_id( "veggy" ) ) ) {
                    z.moves -= rng( cur.get_field_intensity() * 5, cur.get_field_intensity() * 12 );
                    dam += cur.get_field_intensity() * rng( 8, 14 );
                }
                if( z.has_flag( MF_SEES ) ) {
                    z.add_effect( effect_blind, cur.get_field_intensity() * 8_turns );
                }
            }
 
        }
        if( cur_field_type == fd_relax_gas ) {
            if( z.made_of_any( Creature::cmat_fleshnveg ) && !z.has_flag( MF_NO_BREATHE ) ) {
                z.add_effect( effect_stunned, rng( cur.get_field_intensity() * 4_turns,
                                                   cur.get_field_intensity() * 8_turns ) );
            }
        }
        if( cur_field_type == fd_dazzling ) {
            if( z.has_flag( MF_SEES ) && !z.has_flag( MF_ELECTRONIC ) ) {
                z.add_effect( effect_blind, cur.get_field_intensity() * 12_turns );
                z.add_effect( effect_stunned, cur.get_field_intensity() * rng( 5_turns, 12_turns ) );
            }
 
        }
        if( cur_field_type == fd_toxic_gas ) {
            if( !z.has_flag( MF_NO_BREATHE ) ) {
                dam += cur.get_field_intensity();
                z.moves -= cur.get_field_intensity();
            }
 
        }
        if( cur_field_type == fd_nuke_gas ) {
            if( !z.has_flag( MF_NO_BREATHE ) ) {
                if( cur.get_field_intensity() == 3 ) {
                    z.moves -= rng( 60, 120 );
                    dam += rng( 30, 50 );
                } else if( cur.get_field_intensity() == 2 ) {
                    z.moves -= rng( 20, 50 );
                    dam += rng( 10, 25 );
                } else {
                    z.moves -= rng( 0, 15 );
                    dam += rng( 0, 12 );
                }
                if( z.made_of( material_id( "veggy" ) ) ) {
                    z.moves -= rng( cur.get_field_intensity() * 5, cur.get_field_intensity() * 12 );
                    dam *= cur.get_field_intensity();
                }
            }
 
        }
        if( cur_field_type == fd_flame_burst ) {
            // TODO: MATERIALS Use fire resistance
            if( z.has_flag( MF_FIREPROOF ) || z.has_flag( MF_FIREY ) ) {
                return;
            }
            if( z.made_of_any( Creature::cmat_flesh ) ) {
                dam += 3;
            }
            if( z.made_of( material_id( "veggy" ) ) ) {
                dam += 12;
            }
            if( z.made_of( LIQUID ) || z.made_of_any( Creature::cmat_flammable ) ) {
                dam += 50;
            }
            if( z.made_of_any( Creature::cmat_flameres ) ) {
                dam += -25;
            }
            dam += rng( 0, 8 );
            z.moves -= 20;
        }
        if( cur_field_type == fd_electricity ) {
            // We don't want to increase dam, but deal a separate hit so that it can apply effects
            z.deal_damage( nullptr, bodypart_id( "torso" ),
                           damage_instance( DT_ELECTRIC, rng( 1, cur.get_field_intensity() * 3 ) ) );
        }
        if( cur_field_type == fd_fatigue ) {
            if( rng( 0, 2 ) < cur.get_field_intensity() ) {
                dam += cur.get_field_intensity();
                teleport::teleport( z );
            }
        }
        if( cur_field_type == fd_incendiary ) {
            // TODO: MATERIALS Use fire resistance
            if( z.has_flag( MF_FIREPROOF ) || z.has_flag( MF_FIREY ) ) {
                return;
            }
            if( z.made_of_any( Creature::cmat_flesh ) ) {
                dam += 3;
            }
            if( z.made_of( material_id( "veggy" ) ) ) {
                dam += 12;
            }
            if( z.made_of( LIQUID ) || z.made_of_any( Creature::cmat_flammable ) ) {
                dam += 20;
            }
            if( z.made_of_any( Creature::cmat_flameres ) ) {
                dam += -5;
            }
 
            if( cur.get_field_intensity() == 1 ) {
                dam += rng( 2, 6 );
            } else if( cur.get_field_intensity() == 2 ) {
                dam += rng( 6, 12 );
                z.moves -= 20;
                if( !z.made_of( LIQUID ) && !z.made_of_any( Creature::cmat_flameres ) ) {
                    z.add_effect( effect_onfire, rng( 8_turns, 12_turns ) );
                }
            } else if( cur.get_field_intensity() == 3 ) {
                dam += rng( 10, 20 );
                z.moves -= 40;
                if( !z.made_of( LIQUID ) && !z.made_of_any( Creature::cmat_flameres ) ) {
                    z.add_effect( effect_onfire, rng( 12_turns, 16_turns ) );
                }
            }
        }
        if( cur_field_type == fd_fungal_haze ) {
            if( !z.type->in_species( FUNGUS ) &&
                !z.type->has_flag( MF_NO_BREATHE ) &&
                !z.make_fungus() ) {
                // Don't insta-kill jabberwocks, that's silly
                const int intensity = cur.get_field_intensity();
                z.moves -= rng( 10 * intensity, 30 * intensity );
                dam += rng( 0, 10 * intensity );
            }
        }
        if( cur_field_type == fd_fungicidal_gas ) {
            if( z.type->in_species( FUNGUS ) ) {
                const int intensity = cur.get_field_intensity();
                z.moves -= rng( 10 * intensity, 30 * intensity );
                dam += rng( 4, 7 * intensity );
            }
        }
        if( cur_field_type == fd_insecticidal_gas ) {
            if( z.type->in_species( INSECT ) || z.type->in_species( SPIDER ) ) {
                const int intensity = cur.get_field_intensity();
                z.moves -= rng( 10 * intensity, 30 * intensity );
                dam += rng( 4, 7 * intensity );
            }
        }
    }
 
    if( dam > 0 ) {
        z.apply_damage( nullptr, bodypart_id( "torso" ), dam, true );
        z.check_dead_state();
    }
}

References monster::add_effect(), monster::apply_damage(), Creature::check_dead_state(), Creature::cmat_flameres, Creature::cmat_flammable, Creature::cmat_flesh, Creature::cmat_fleshnveg, Creature::deal_damage(), monster::digging(), monster::digs(), DT_ACID, DT_ELECTRIC, DT_HEAT, effect_blind, effect_corroding, effect_onfire, effect_stunned, effect_webbed, fd_acid, fd_dazzling, fd_electricity, fd_fatigue, fd_fire, fd_flame_burst, fd_fungal_haze, fd_fungicidal_gas, fd_incendiary, fd_insecticidal_gas, fd_nuke_gas, fd_relax_gas, fd_sap, fd_sludge, fd_smoke, fd_tear_gas, fd_toxic_gas, fd_web, monster::flies(), FUNGUS, monster::get_armor_type(), get_field(), field_entry::get_field_intensity(), field_entry::get_field_type(), monster::has_flag(), mtype::has_flag(), mtype::in_species(), INSECT, field_entry::is_field_alive(), LIQUID, monster::made_of(), monster::made_of_any(), monster::make_fungus(), MF_ELECTRONIC, MF_FIREPROOF, MF_FIREY, MF_NO_BREATHE, MF_SEES, MF_SLUDGEPROOF, MF_WEBWALK, Creature::moves, num_bp, one_in(), monster::pos(), rng(), field_entry::set_field_intensity(), SPIDER, teleport::teleport(), monster::type, and veh_at().

Referenced by creature_in_field().

◆ mop_spills()

bool map::mop_spills ( const tripoint & p )

Remove moppable fields/items at this location.

Parameters

p	the location

Returns: true if anything moppable was there, false otherwise.

Definition at line 2857 of file map.cpp.

{
    bool retval = false;
 
    if( !has_flag( "LIQUIDCONT", p ) && !has_flag( "SEALED", p ) ) {
        auto items = i_at( p );
        auto new_end = std::remove_if( items.begin(), items.end(), []( const item & it ) {
            return it.made_of( LIQUID );
        } );
        retval = new_end != items.end();
        while( new_end != items.end() ) {
            new_end = items.erase( new_end );
        }
    }
 
    field &fld = field_at( p );
    static const std::vector<field_type_id> to_check = {
        fd_blood,
        fd_blood_veggy,
        fd_blood_insect,
        fd_blood_invertebrate,
        fd_gibs_flesh,
        fd_gibs_veggy,
        fd_gibs_insect,
        fd_gibs_invertebrate,
        fd_bile,
        fd_slime,
        fd_sludge
    };
    for( field_type_id fid : to_check ) {
        retval |= fld.remove_field( fid );
    }
 
    if( const optional_vpart_position vp = veh_at( p ) ) {
        vehicle *const veh = &vp->vehicle();
        std::vector<int> parts_here = veh->parts_at_relative( vp->mount(), true );
        for( auto &elem : parts_here ) {
            if( veh->part( elem ).blood > 0 ) {
                veh->part( elem ).blood = 0;
                retval = true;
            }
            //remove any liquids that somehow didn't fall through to the ground
            vehicle_stack here = veh->get_items( elem );
            auto new_end = std::remove_if( here.begin(), here.end(), []( const item & it ) {
                return it.made_of( LIQUID );
            } );
            retval |= ( new_end != here.end() );
            while( new_end != here.end() ) {
                new_end = here.erase( new_end );
            }
        }
    } // if veh != 0
    return retval;
}

References vehicle_part::blood, fd_bile, fd_blood, fd_blood_insect, fd_blood_invertebrate, fd_blood_veggy, fd_gibs_flesh, fd_gibs_insect, fd_gibs_invertebrate, fd_gibs_veggy, fd_slime, fd_sludge, field_at(), vehicle::get_items(), has_flag(), anonymous_namespace{iexamine_elevator.cpp}::elevator::here(), i_at(), vehicle::part(), vehicle::parts_at_relative(), field::remove_field(), veh_at(), and vehicle::vehicle().

◆ move_cost() [1/2]

int map::move_cost	(	const tripoint &	p,
		const vehicle *	ignored_vehicle = `nullptr`
	)		const

Calculate the cost to move past the tile at p.

The move cost is determined by various obstacles, such as terrain, vehicles and furniture.

Note: Movement costs for players and zombies both use this function.

Returns

The return value is interpreted as follows:

Move Cost	Meaning
0	Impassable. Use `passable`/`impassable` to check for this.
n > 0	x*n turns to move past this

Definition at line 1845 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return 0;
    }
 
    const furn_t &furniture = furn( p ).obj();
    const ter_t &terrain = ter( p ).obj();
    const optional_vpart_position vp = veh_at( p );
    vehicle *const veh = ( !vp || &vp->vehicle() == ignored_vehicle ) ? nullptr : &vp->vehicle();
    const int part = veh ? vp->part_index() : -1;
 
    return move_cost_internal( furniture, terrain, veh, part );
}

References furn(), furniture, inbounds(), move_cost_internal(), int_id< T >::obj(), ter(), terrain, and veh_at().

Referenced by combined_movecost(), draw_mine(), move_cost(), obstacle_coverage(), passable(), game::print_terrain_info(), reachable_flood_steps(), game::vertical_move(), and game::walk_move().

◆ move_cost() [2/2]

int map::move_cost	(	point	p,
		const vehicle *	ignored_vehicle = `nullptr`
	)		const

inline

Definition at line 562 of file map.h.

                                                                                 {
            return move_cost( tripoint( p, abs_sub.z ), ignored_vehicle );
        }

References abs_sub, move_cost(), and tripoint::z.

◆ move_cost_internal()

int map::move_cost_internal	(	const furn_t &	furniture,
		const ter_t &	terrain,
		const vehicle *	veh,
		int	vpart
	)		const

private

Internal versions of public functions to avoid checking same variables multiple times.

They lack safety checks, because their callers already do those.

Definition at line 1808 of file map.cpp.

{
    if( terrain.movecost == 0 || ( furniture.id && furniture.movecost < 0 ) ) {
        return 0;
    }
 
    if( veh != nullptr ) {
        const vpart_position vp( const_cast<vehicle &>( *veh ), vpart );
        if( vp.obstacle_at_part() ) {
            return 0;
        } else if( vp.part_with_feature( VPFLAG_AISLE, true ) ) {
            return 2;
        } else {
            return 8;
        }
    }
 
    if( furniture.id ) {
        return std::max( terrain.movecost + furniture.movecost, 0 );
    }
 
    return std::max( terrain.movecost, 0 );
}

References furniture, vpart_position::obstacle_at_part(), vpart_position::part_with_feature(), terrain, and VPFLAG_AISLE.

Referenced by move_cost(), route(), and update_pathfinding_cache().

◆ move_cost_ter_furn() [1/2]

int map::move_cost_ter_furn ( const tripoint & p ) const

Similar behavior to move_cost(), but ignores vehicles.

Definition at line 1870 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return 0;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    const int tercost = current_submap->get_ter( l ).obj().movecost;
    if( tercost == 0 ) {
        return 0;
    }
 
    const int furncost = current_submap->get_furn( l ).obj().movecost;
    if( furncost < 0 ) {
        return 0;
    }
 
    const int cost = tercost + furncost;
    return cost > 0 ? cost : 0;
}

References submap::get_furn(), get_submap_at(), submap::get_ter(), inbounds(), map_data_common_t::movecost, and int_id< T >::obj().

Referenced by move_cost_ter_furn(), passable_ter_furn(), and vehicle_wheel_traction().

◆ move_cost_ter_furn() [2/2]

int map::move_cost_ter_furn ( point p ) const

inline

Definition at line 579 of file map.h.

                                                {
            return move_cost_ter_furn( tripoint( p, abs_sub.z ) );
        }

References abs_sub, move_cost_ter_furn(), and tripoint::z.

◆ move_vehicle()

vehicle * map::move_vehicle	(	vehicle &	veh,
		const tripoint &	dp,
		const tileray &	facing
	)

Definition at line 580 of file map.cpp.

{
    if( dp == tripoint_zero ) {
        debugmsg( "Empty displacement vector" );
        return &veh;
    } else if( std::abs( dp.x ) > 1 || std::abs( dp.y ) > 1 || std::abs( dp.z ) > 1 ) {
        debugmsg( "Invalid displacement vector: %d, %d, %d", dp.x, dp.y, dp.z );
        return &veh;
    }
    // Split the movement into horizontal and vertical for easier processing
    if( dp.xy() != point_zero && dp.z != 0 ) {
        vehicle *const new_pointer = move_vehicle( veh, tripoint( dp.xy(), 0 ), facing );
        if( !new_pointer ) {
            return nullptr;
        }
 
        vehicle *const result = move_vehicle( *new_pointer, tripoint( 0, 0, dp.z ), facing );
        if( !result ) {
            return nullptr;
        }
 
        result->is_falling = false;
        return result;
    }
    const bool vertical = dp.z != 0;
    // Ensured by the splitting above
    assert( vertical == ( dp.xy() == point_zero ) );
 
    const int target_z = dp.z + veh.sm_pos.z;
    if( target_z < -OVERMAP_DEPTH || target_z > OVERMAP_HEIGHT ) {
        return &veh;
    }
 
    veh.precalc_mounts( 1, veh.skidding ? veh.turn_dir : facing.dir(), veh.pivot_point() );
 
    // cancel out any movement of the vehicle due only to a change in pivot
    tripoint dp1 = dp - veh.pivot_displacement();
 
    if( !vertical ) {
        veh.adjust_zlevel( 1, dp1 );
    }
 
    int impulse = 0;
 
    std::vector<veh_collision> collisions;
 
    // Find collisions
    // Velocity of car before collision
    // Split into vertical and horizontal movement
    const int &coll_velocity = vertical ? veh.vertical_velocity : veh.velocity;
    const int velocity_before = coll_velocity;
    if( velocity_before == 0 && !veh.is_rotorcraft() && !veh.is_flying_in_air() ) {
        debugmsg( "%s tried to move %s with no velocity",
                  veh.name, vertical ? "vertically" : "horizontally" );
        return &veh;
    }
 
    bool veh_veh_coll_flag = false;
    // Try to collide multiple times
    size_t collision_attempts = 10;
    do {
        collisions.clear();
        veh.collision( collisions, dp1, false );
 
        // Vehicle collisions
        std::map<vehicle *, std::vector<veh_collision> > veh_collisions;
        for( auto &coll : collisions ) {
            if( coll.type != veh_coll_veh ) {
                continue;
            }
 
            veh_veh_coll_flag = true;
            // Only collide with each vehicle once
            veh_collisions[ static_cast<vehicle *>( coll.target ) ].push_back( coll );
        }
 
        for( auto &pair : veh_collisions ) {
            impulse += vehicle_vehicle_collision( veh, *pair.first, pair.second );
        }
 
        // Non-vehicle collisions
        for( const auto &coll : collisions ) {
            if( coll.type == veh_coll_veh ) {
                continue;
            }
            if( coll.part > veh.part_count() ||
                veh.part( coll.part ).removed ) {
                continue;
            }
 
            point collision_point = veh.part( coll.part ).mount;
            const int coll_dmg = coll.imp;
            // Shock damage, if the target part is a rotor treat as an aimed hit.
            if( veh.part_info( coll.part ).rotor_diameter() > 0 ) {
                veh.damage( coll.part, coll_dmg, DT_BASH, true );
            } else {
                impulse += coll_dmg;
                veh.damage( coll.part, coll_dmg, DT_BASH );
                veh.damage_all( coll_dmg / 2, coll_dmg, DT_BASH, collision_point );
            }
        }
 
        // prevent vehicle bouncing after the first collision
        if( vertical && velocity_before < 0 && coll_velocity > 0 ) {
            veh.vertical_velocity = 0; // also affects `coll_velocity` and thus exits the loop
        }
 
    } while( collision_attempts-- > 0 && coll_velocity != 0 &&
             sgn( coll_velocity ) == sgn( velocity_before ) &&
             !collisions.empty() && !veh_veh_coll_flag );
 
    const int velocity_after = coll_velocity;
    bool can_move = velocity_after != 0 && sgn( velocity_after ) == sgn( velocity_before );
    if( dp.z != 0 && veh.is_rotorcraft() ) {
        can_move = true;
    }
    units::angle coll_turn = 0_degrees;
    if( impulse > 0 ) {
        coll_turn = shake_vehicle( veh, velocity_before, facing.dir() );
        veh.stop_autodriving();
        const int volume = std::min<int>( 100, std::sqrt( impulse ) );
        // TODO: Center the sound at weighted (by impulse) average of collisions
        sounds::sound( veh.global_pos3(), volume, sounds::sound_t::combat, _( "crash!" ),
                       false, "smash_success", "hit_vehicle" );
    }
 
    if( veh_veh_coll_flag ) {
        // Break here to let the hit vehicle move away
        return nullptr;
    }
 
    // If not enough wheels, mess up the ground a bit.
    if( !vertical && !veh.valid_wheel_config() && !veh.is_in_water() && !veh.is_flying_in_air() &&
        dp.z == 0 ) {
        veh.velocity += veh.velocity < 0 ? 2000 : -2000;
        for( const auto &p : veh.get_points() ) {
            const ter_id &pter = ter( p );
            if( pter == t_dirt || pter == t_grass ) {
                ter_set( p, t_dirtmound );
            }
        }
    }
 
    const units::angle last_turn_dec = 1_degrees;
    if( veh.last_turn < 0_degrees ) {
        veh.last_turn += last_turn_dec;
        if( veh.last_turn > -last_turn_dec ) {
            veh.last_turn = 0_degrees;
        }
    } else if( veh.last_turn > 0_degrees ) {
        veh.last_turn -= last_turn_dec;
        if( veh.last_turn < last_turn_dec ) {
            veh.last_turn = 0_degrees;
        }
    }
 
    Character &player_character = get_player_character();
    const bool seen = sees_veh( player_character, veh, false );
 
    if( can_move || ( vertical && veh.is_falling ) ) {
        // Accept new direction
        if( veh.skidding ) {
            veh.face.init( veh.turn_dir );
        } else {
            veh.face = facing;
        }
 
        veh.move = facing;
        if( coll_turn != 0_degrees ) {
            veh.skidding = true;
            veh.turn( coll_turn );
        }
        veh.on_move();
        // Actually change position
        displace_vehicle( veh, dp1 );
        veh.shift_zlevel();
    } else if( !vertical ) {
        veh.stop();
    }
    veh.check_falling_or_floating();
    // If the PC is in the currently moved vehicle, adjust the
    //  view offset.
    if( g->u.controlling_vehicle && veh_pointer_or_null( veh_at( g->u.pos() ) ) == &veh ) {
        g->calc_driving_offset( &veh );
        if( veh.skidding && can_move ) {
            // TODO: Make skid recovery in air hard
            veh.possibly_recover_from_skid();
        }
    }
    // Now we're gonna handle traps we're standing on (if we're still moving).
    if( !vertical && can_move ) {
        const auto wheel_indices = veh.wheelcache; // Don't use a reference here, it causes a crash.
 
        // Values to deal with crushing items.
        // The math needs to be floating-point to work, so the values might as well be.
        const float vehicle_grounded_wheel_area = static_cast<int>( vehicle_wheel_traction( veh, true ) );
        const float weight_to_damage_factor = 0.05; // Nobody likes a magic number.
        const float vehicle_mass_kg = to_kilogram( veh.total_mass() );
 
        for( auto &w : wheel_indices ) {
            const tripoint wheel_p = veh.global_part_pos3( w );
            if( one_in( 2 ) && displace_water( wheel_p ) ) {
                sounds::sound( wheel_p, 4,  sounds::sound_t::movement, _( "splash!" ), false,
                               "environment", "splash" );
            }
 
            veh.handle_trap( wheel_p, w );
            if( !has_flag( "SEALED", wheel_p ) ) {
                const float wheel_area =  veh.part( w ).wheel_area();
 
                // Damage is calculated based on the weight of the vehicle,
                // The area of it's wheels, and the area of the wheel running over the items.
                // This number is multiplied by weight_to_damage_factor to get reasonable results, damage-wise.
                const int wheel_damage = static_cast<int>( ( ( wheel_area / vehicle_grounded_wheel_area ) *
                                         vehicle_mass_kg ) * weight_to_damage_factor );
 
                //~ %1$s: vehicle name
                smash_items( wheel_p, wheel_damage, string_format( _( "weight of %1$s" ), veh.disp_name() ),
                             false );
            }
        }
    }
    if( veh.is_towing() ) {
        veh.do_towing_move();
        // veh.do_towing_move() may cancel towing, so we need to recheck is_towing here
        if( veh.is_towing() && veh.tow_data.get_towed()->tow_cable_too_far() ) {
            add_msg( m_info, _( "A towing cable snaps off of %s." ),
                     veh.tow_data.get_towed()->disp_name() );
            veh.tow_data.get_towed()->invalidate_towing( true );
        }
    }
    // Redraw scene, but only if the player is not engaged in an activity and
    // the vehicle was seen before or after the move.
    if( !player_character.activity && ( seen || sees_veh( player_character, veh, true ) ) ) {
        g->invalidate_main_ui_adaptor();
        inp_mngr.pump_events();
        ui_manager::redraw_invalidated();
        refresh_display();
    }
    return &veh;
}

References _, Character::activity, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), sounds::combat, vehicle::damage(), vehicle::damage_all(), debugmsg, tileray::dir(), vehicle::disp_name(), displace_vehicle(), displace_water(), vehicle::do_towing_move(), DT_BASH, vehicle::face, g, get_player_character(), vehicle::get_points(), towing_data::get_towed(), vehicle::global_part_pos3(), vehicle::global_pos3(), vehicle::handle_trap(), has_flag(), tileray::init(), inp_mngr, vehicle::invalidate_towing(), vehicle::is_falling, vehicle::is_flying_in_air(), vehicle::is_in_water(), vehicle::is_rotorcraft(), vehicle::is_towing(), vehicle::last_turn, m_info, vehicle_part::mount, vehicle::move, move_vehicle(), sounds::movement, vehicle::name, vehicle::on_move(), one_in(), OVERMAP_HEIGHT, vehicle::part(), vehicle::part_count(), vehicle::part_info(), vehicle::pivot_displacement(), vehicle::pivot_point(), point_zero, vehicle::possibly_recover_from_skid(), vehicle::precalc_mounts(), input_manager::pump_events(), ui_manager::redraw_invalidated(), refresh_display(), vehicle_part::removed, vpart_info::rotor_diameter(), sees_veh(), sgn(), shake_vehicle(), vehicle::shift_zlevel(), vehicle::skidding, vehicle::sm_pos, smash_items(), sounds::sound(), vehicle::stop(), vehicle::stop_autodriving(), string_format(), t_dirt, t_dirtmound, t_grass, ter(), ter_set(), units::to_kilogram(), vehicle::total_mass(), vehicle::tow_cable_too_far(), vehicle::tow_data, tripoint_zero, vehicle::turn(), vehicle::turn_dir, vehicle::valid_wheel_config(), veh_at(), veh_coll_veh, veh_pointer_or_null(), vehicle_vehicle_collision(), vehicle_wheel_traction(), vehicle::velocity, vehicle::vertical_velocity, vehicle_part::wheel_area(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by move_vehicle().

◆ name() [1/2]

std::string map::name ( const tripoint & p )

Definition at line 1390 of file map.cpp.

{
    return has_furn( p ) ? furnname( p ) : tername( p );
}

References furnname(), has_furn(), and tername().

Referenced by add_camp(), add_computer(), add_spawn(), doors::close_door(), item_location::impl::item_on_map::describe(), disp_name(), game::disp_NPCs(), game::examine(), game::get_dangerous_tile(), pickup::handle_spillable_contents(), game::list_monsters(), name(), obstacle_name(), place_spawns(), and game::walk_move().

◆ name() [2/2]

std::string map::name ( point p )

inline

Definition at line 779 of file map.h.

                                  {
            return name( tripoint( p, abs_sub.z ) );
        }

References abs_sub, name(), and tripoint::z.

◆ obscured_by_vehicle_rotation()

bool map::obscured_by_vehicle_rotation	(	const tripoint &	from,
		const tripoint &	to
	)		const

Checks if a rotated vehicle is blocking diagonal vision, tripoints must be adjacent.

Definition at line 6660 of file map.cpp.

{
    if( !inbounds( from ) || !inbounds( to ) ) {
        return false;
    }
 
    if( from.z != to.z ) {
        //Split it into two checks, one for each z level
        tripoint flattened = {from.xy(), to.z};
        if( obscured_by_vehicle_rotation( flattened, to ) ) {
            return true;
        }
    }
 
    point delta = to.xy() - from.xy();
 
    auto cache = get_cache( from.z ).vehicle_obscured_cache;
 
    if( delta == point_north_west ) {
        return cache[from.x][from.y].nw;
    }
 
    if( delta == point_north_east ) {
        return cache[from.x][from.y].ne;
    }
 
    if( delta == point_south_west ) {
        return cache[to.x][to.y].ne;
    }
    if( delta == point_south_east ) {
        return cache[to.x][to.y].nw;
    }
 
    return false;
}

References get_cache(), inbounds(), diagonal_blocks::nw, obscured_by_vehicle_rotation(), point_north_east, point_north_west, point_south_east, point_south_west, level_cache::vehicle_obscured_cache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by obscured_by_vehicle_rotation(), and sees().

◆ obstacle_coverage()

int map::obstacle_coverage	(	const tripoint &	loc1,
		const tripoint &	loc2
	)		const

Returns coverage of target in relation to the observer.

Target is loc2, observer is loc1. First tile from the target is an obstacle, which has the coverage value. If there's no obstacle adjacent to the target - no coverage.

Definition at line 6357 of file map.cpp.

{
    // Can't hide if you are standing on furniture, or non-flat slowing-down terrain tile.
    if( furn( loc2 ).obj().id || ( move_cost( loc2 ) > 2 && !has_flag_ter( TFLAG_FLAT, loc2 ) ) ) {
        return 0;
    }
    const point a( std::abs( loc1.x - loc2.x ) * 2, std::abs( loc1.y - loc2.y ) * 2 );
    int offset = std::min( a.x, a.y ) - ( std::max( a.x, a.y ) / 2 );
    tripoint obstaclepos;
    bresenham( loc2, loc1, offset, 0, [&obstaclepos]( const tripoint & new_point ) {
        // Only adjacent tile between you and enemy is checked for cover.
        obstaclepos = new_point;
        return false;
    } );
    if( const auto obstacle_f = furn( obstaclepos ) ) {
        return obstacle_f->coverage;
    }
    if( const auto vp = veh_at( obstaclepos ) ) {
        if( vp->obstacle_at_part() ) {
            return 60;
        } else if( !vp->part_with_feature( VPFLAG_AISLE, true ) ) {
            return 45;
        }
    }
    return ter( obstaclepos )->coverage;
}

References a, bresenham(), map_data_common_t::coverage, furn(), has_flag_ter(), move_cost(), ter(), TFLAG_FLAT, veh_at(), VPFLAG_AISLE, tripoint::x, and tripoint::y.

◆ obstacle_name()

std::string map::obstacle_name ( const tripoint & p )

Returns the name of the obstacle at p that might be blocking movement/projectiles/etc.

Note that this only accounts for vehicles, terrain, and furniture.

Definition at line 1400 of file map.cpp.

{
    if( const std::optional<vpart_reference> vp = veh_at( p ).obstacle_at_part() ) {
        return vp->info().name();
    }
    return name( p );
}

References name(), and veh_at().

Referenced by avatar_action::move().

◆ obstructed_by_vehicle_rotation()

bool map::obstructed_by_vehicle_rotation	(	const tripoint &	from,
		const tripoint &	to
	)		const

Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.

Definition at line 6623 of file map.cpp.

{
    if( !inbounds( from ) || !inbounds( to ) ) {
        return false;
    }
 
    if( from.z != to.z ) {
        //Split it into two checks, one for each z level
        tripoint flattened = {from.xy(), to.z};
        if( obstructed_by_vehicle_rotation( flattened, to ) ) {
            return true;
        }
    }
 
    point delta = to.xy() - from.xy();
 
    auto cache = get_cache( from.z ).vehicle_obstructed_cache;
 
    if( delta == point_north_west ) {
        return cache[from.x][from.y].nw;
    }
 
    if( delta == point_north_east ) {
        return cache[from.x][from.y].ne;
    }
 
    if( delta == point_south_west ) {
        return cache[to.x][to.y].ne;
    }
    if( delta == point_south_east ) {
        return cache[to.x][to.y].nw;
    }
 
    return false;
}

References get_cache(), inbounds(), diagonal_blocks::nw, obstructed_by_vehicle_rotation(), point_north_east, point_north_west, point_south_east, point_south_west, level_cache::vehicle_obstructed_cache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by add_splatter_trail(), monster::can_squeeze_to(), clear_path(), clear_shot_reach(), game::fling_creature(), gas_can_spread_to(), game::knockback(), avatar_action::move(), obstructed_by_vehicle_rotation(), game::peek(), npc::pick_up_item(), process_fields_in_submap(), and propagate_field().

◆ on_vehicle_moved()

void map::on_vehicle_moved ( int smz )

Callback invoked when a vehicle has moved.

Definition at line 465 of file map.cpp.

{
    set_outside_cache_dirty( smz );
    set_transparency_cache_dirty( smz );
    set_floor_cache_dirty( smz );
    set_floor_cache_dirty( smz + 1 );
    set_pathfinding_cache_dirty( smz );
}

References set_floor_cache_dirty(), set_outside_cache_dirty(), set_pathfinding_cache_dirty(), and set_transparency_cache_dirty().

Referenced by displace_vehicle().

◆ open_door()

bool map::open_door	(	const tripoint &	p,
		bool	inside,
		bool	check_only = `false`
	)

Definition at line 3978 of file map.cpp.

{
    avatar &you = get_avatar();
    const auto &ter = this->ter( p ).obj();
    const auto &furn = this->furn( p ).obj();
 
    if( ter.open ) {
        if( has_flag( "OPENCLOSE_INSIDE", p ) && !inside ) {
            return false;
        }
        if( you.is_mounted() ) {
            auto mon = you.mounted_creature.get();
            if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                add_msg( m_info, _( "You can't open things while you're riding." ) );
                return false;
            }
        }
        if( !check_only ) {
            sounds::sound( p, 6, sounds::sound_t::movement, _( "swish" ), true,
                           "open_door", ter.id.str() );
            ter_set( p, ter.open );
 
            if( ( you.has_trait( trait_id( "SCHIZOPHRENIC" ) ) || you.has_artifact_with( AEP_SCHIZO ) )
                && one_in( 50 ) && !ter.has_flag( "TRANSPARENT" ) ) {
                tripoint mp = p + -2 * you.pos().xy() + tripoint( 2 * p.x, 2 * p.y, p.z );
                g->spawn_hallucination( mp );
            }
        }
 
        return true;
    } else if( furn.open ) {
        if( has_flag( "OPENCLOSE_INSIDE", p ) && !inside ) {
            return false;
        }
        if( you.is_mounted() ) {
            auto mon = you.mounted_creature.get();
            if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                add_msg( m_info, _( "You can't open things while you're riding." ) );
                return false;
            }
        }
 
        if( !check_only ) {
            sounds::sound( p, 6, sounds::sound_t::movement, _( "swish" ), true,
                           "open_door", furn.id.str() );
            furn_set( p, furn.open );
        }
 
        return true;
    } else if( const optional_vpart_position vp = veh_at( p ) ) {
        int openable = vp->vehicle().next_part_to_open( vp->part_index(), true );
        if( openable >= 0 ) {
            if( you.is_mounted() ) {
                auto mon = you.mounted_creature.get();
                if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
                    add_msg( m_info, _( "You can't open things while you're riding." ) );
                    return false;
                }
            }
            if( !check_only ) {
                if( !vp->vehicle().handle_potential_theft( you ) ) {
                    return false;
                }
                vp->vehicle().open_all_at( openable );
            }
 
            return true;
        }
 
        return false;
    }
 
    return false;
}

References _, add_msg(), AEP_SCHIZO, furn(), furn_set(), g, get_avatar(), Character::has_artifact_with(), has_flag(), Character::has_trait(), int_id< T >::id(), Character::is_mounted(), m_info, MF_RIDEABLE_MECH, Character::mounted_creature, sounds::movement, int_id< T >::obj(), one_in(), Character::pos(), sounds::sound(), string_id< T >::str(), ter(), ter_set(), veh_at(), tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by npc::can_open_door(), avatar_action::move(), and rate_location().

◆ operator=() [1/2]

map & map::operator= ( const map & )

delete

◆ operator=() [2/2]

map & map::operator= ( map && )

default

◆ partial_con_at()

partial_con * map::partial_con_at ( const tripoint & p )

Definition at line 5274 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return nullptr;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    auto it = current_submap->partial_constructions.find( tripoint( l, p.z ) );
    if( it != current_submap->partial_constructions.end() ) {
        return &it->second;
    }
    return nullptr;
}

References get_submap_at(), inbounds(), submap::partial_constructions, and tripoint::z.

Referenced by player_activity::get_progress_message(), and game::print_trap_info().

◆ partial_con_remove()

void map::partial_con_remove ( const tripoint & p )

Definition at line 5288 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    current_submap->partial_constructions.erase( tripoint( l, p.z ) );
}

References get_submap_at(), inbounds(), submap::partial_constructions, and tripoint::z.

◆ partial_con_set()

void map::partial_con_set	(	const tripoint &	p,
		const partial_con &	con
	)

Definition at line 5298 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    if( !current_submap->partial_constructions.emplace( tripoint( l, p.z ), con ).second ) {
        debugmsg( "set partial con on top of terrain which already has a partial con" );
    }
}

References debugmsg, get_submap_at(), inbounds(), submap::partial_constructions, and tripoint::z.

◆ passable() [1/2]

bool map::passable ( const tripoint & p ) const

Definition at line 1865 of file map.cpp.

{
    return move_cost( p ) != 0;
}

References move_cost().

Referenced by game::fling_creature(), generate(), game::grabbed_furn_move(), hit_with_acid(), hit_with_fire(), impassable(), game::is_empty(), MapExtras::mx_collegekids(), MapExtras::mx_corpses(), MapExtras::mx_house_spider(), MapExtras::mx_looters(), MapExtras::mx_marloss_pilgrimage(), MapExtras::mx_military(), MapExtras::mx_roadblock(), MapExtras::mx_science(), MapExtras::mx_supplydrop(), passable(), process_fields_in_submap(), avatar_action::ramp_move(), rate_location(), spawn_monsters_submap_group(), place_npc_iuse::use(), valid_move(), and game::vertical_move().

◆ passable() [2/2]

bool map::passable ( point p ) const

inline

Definition at line 570 of file map.h.

                                       {
            return passable( tripoint( p, abs_sub.z ) );
        }

References abs_sub, passable(), and tripoint::z.

◆ passable_ter_furn()

bool map::passable_ter_furn ( const tripoint & p ) const

Definition at line 1898 of file map.cpp.

{
    return move_cost_ter_furn( p ) != 0;
}

References move_cost_ter_furn().

Referenced by impassable_ter_furn(), and avatar_action::move().

◆ pl_line_of_sight()

bool map::pl_line_of_sight	(	const tripoint &	t,
		int	max_range
	)		const

Uses the map cache to tell if the player could see the given square.

pl_sees implies pl_line_of_sight Used for infrared.

Definition at line 831 of file lightmap.cpp.

{
    if( !inbounds( t ) ) {
        return false;
    }
 
    if( max_range >= 0 && square_dist( t, g->u.pos() ) > max_range ) {
        // Out of range!
        return false;
    }
 
    const auto &map_cache = get_cache_ref( t.z );
    // Any epsilon > 0 is fine - it means lightmap processing visited the point
    return map_cache.seen_cache[t.x][t.y] > 0.0f ||
           map_cache.camera_cache[t.x][t.y] > 0.0f;
}

References g, get_cache_ref(), inbounds(), square_dist(), tripoint::x, tripoint::y, and tripoint::z.

◆ pl_sees()

bool map::pl_sees	(	const tripoint &	t,
		int	max_range
	)		const

Whether the player character (g->u) can see the given square (local map coordinates).

This only checks the transparency of the path to the target, the light level is not checked.

Parameters

t	Target point to look at
max_range	All squares that are further away than this are invisible. Ignored if smaller than 0.

Definition at line 813 of file lightmap.cpp.

{
    if( !inbounds( t ) ) {
        return false;
    }
 
    if( max_range >= 0 && square_dist( t, g->u.pos() ) > max_range ) {
        return false;    // Out of range!
    }
 
    const auto &map_cache = get_cache_ref( t.z );
    const apparent_light_info a = apparent_light_helper( map_cache, t );
    const float light_at_player = map_cache.lm[g->u.posx()][g->u.posy()].max();
    return !a.obstructed &&
           ( a.apparent_light >= g->u.get_vision_threshold( light_at_player ) ||
             map_cache.sm[t.x][t.y] > 0.0 );
}

References a, apparent_light_helper(), g, get_cache_ref(), inbounds(), square_dist(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by sounds::process_sound_markers(), and Character::sees().

◆ place_gas_pump() [1/2]

void map::place_gas_pump	(	point	p,
		int	charges
	)

Definition at line 5286 of file mapgen.cpp.

{
    place_gas_pump( p, charges, one_in( 4 ) ? "diesel" : "gasoline" );
}

References one_in(), and place_gas_pump().

◆ place_gas_pump() [2/2]

void map::place_gas_pump	(	point	p,
		int	charges,
		const std::string &	fuel_type
	)

Definition at line 5278 of file mapgen.cpp.

{
    item fuel( fuel_type, calendar::start_of_cataclysm );
    fuel.charges = charges;
    add_item( p, fuel );
    ter_set( p, ter_id( fuel.fuel_pump_terrain() ) );
}

References add_item(), item::charges, item::fuel_pump_terrain(), calendar::start_of_cataclysm, ter_id, and ter_set().

Referenced by jmapgen_gaspump::apply(), mapgen_tutorial(), and place_gas_pump().

◆ place_items() [1/2]

std::vector< item * > map::place_items	(	const item_group_id &	loc,
		int	chance,
		const tripoint &	p1,
		const tripoint &	p2,
		bool	ongrass,
		const time_point &	turn,
		int	magazine = `0`,
		int	ammo = `0`
	)

Place items from item group in the rectangle f - t.

Several items may be spawned on different places. Several items may spawn at once (at one place) when the item group says so (uses item_group::items_from which may return several items at once).

Parameters

loc	Current location of items to be placed
chance	Chance for more items. A chance of 100 creates 1 item all the time, otherwise it's the chance that more items will be created (place items until the random roll with that chance fails). The chance is used for the first item as well, so it may not spawn an item at all. Values <= 0 or > 100 are invalid.
p1	One corner of rectangle in which to spawn items
p2	Second corner of rectangle in which to spawn items
ongrass	If false the items won't spawn on flat terrain (grass, floor, ...).
turn	The birthday that the created items shall have.
magazine	percentage chance item will contain the default magazine
ammo	percentage chance item will be filled with default ammo

Returns: vector containing all placed items

Definition at line 5351 of file mapgen.cpp.

{
    // TODO: implement for 3D
    std::vector<item *> res;
 
    if( chance > 100 || chance <= 0 ) {
        debugmsg( "map::place_items() called with an invalid chance (%d)", chance );
        return res;
    }
    if( !item_group::group_is_defined( loc ) ) {
        // TODO: fix point types
        const tripoint_abs_omt omt( sm_to_omt_copy( get_abs_sub() ) );
        const oter_id &oid = overmap_buffer.ter( omt );
        debugmsg( "place_items: invalid item group '%s', om_terrain = '%s' (%s)",
                  loc.c_str(), oid.id().c_str(), oid->get_mapgen_id().c_str() );
        return res;
    }
 
    const float spawn_rate = get_option<float>( "ITEM_SPAWNRATE" );
    int spawn_count = roll_remainder( chance * spawn_rate / 100.0f );
    for( int i = 0; i < spawn_count; i++ ) {
        // Might contain one item or several that belong together like guns & their ammo
        int tries = 0;
        auto is_valid_terrain = [this, ongrass]( point  p ) {
            auto &terrain = ter( p ).obj();
            return terrain.movecost == 0           &&
                   !terrain.has_flag( "PLACE_ITEM" ) &&
                   !ongrass                                   &&
                   !terrain.has_flag( "FLAT" );
        };
 
        point p;
        do {
            p.x = rng( p1.x, p2.x );
            p.y = rng( p1.y, p2.y );
            tries++;
        } while( is_valid_terrain( p ) && tries < 20 );
        if( tries < 20 ) {
            auto put = put_items_from_loc( loc, tripoint( p, abs_sub.z ), turn );
            res.insert( res.end(), put.begin(), put.end() );
        }
    }
    for( auto e : res ) {
        if( e->is_tool() || e->is_gun() || e->is_magazine() ) {
            if( rng( 0, 99 ) < magazine && !e->magazine_integral() && !e->magazine_current() ) {
                e->put_in( item( e->magazine_default(), e->birthday() ) );
            }
            if( rng( 0, 99 ) < ammo && e->ammo_remaining() == 0 ) {
                e->ammo_set( e->ammo_default(), e->ammo_capacity() );
            }
        }
    }
    return res;
}

References abs_sub, string_id< T >::c_str(), debugmsg, get_abs_sub(), oter_t::get_mapgen_id(), item_group::group_is_defined(), int_id< T >::id(), int_id< T >::obj(), coords::omt, overmap_buffer, put_items_from_loc(), rng(), roll_remainder(), sm_to_omt_copy(), ter(), overmapbuffer::ter(), terrain, calendar::turn, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by jmapgen_item_group::apply(), draw_mine(), draw_office_tower(), draw_slimepit(), mapgen_ants_food(), mapgen_ants_larvae(), mapgen_ants_larvae_acid(), mapgen_ants_queen(), mapgen_ants_queen_acid(), mapgen_cavern(), mapgen_crater(), mapgen_field(), mapgen_forest(), mapgen_forest_trail_curved(), mapgen_forest_trail_four_way(), mapgen_forest_trail_straight(), mapgen_forest_trail_tee(), mapgen_highway(), mapgen_hive(), mapgen_parking_lot(), mapgen_road(), mapgen_sewer_curved(), mapgen_sewer_four_way(), mapgen_sewer_straight(), mapgen_sewer_tee(), MapExtras::mx_collegekids(), MapExtras::mx_drugdeal(), MapExtras::mx_house_spider(), MapExtras::mx_house_wasp(), MapExtras::mx_military(), MapExtras::mx_minefield(), MapExtras::mx_roadblock(), MapExtras::mx_roadworks(), MapExtras::mx_science(), MapExtras::mx_supplydrop(), place_items(), place_vending(), mission_start::ranch_nurse_8(), mission_start::ranch_scavenger_1(), mission_start::ranch_scavenger_2(), mission_start::ranch_scavenger_3(), and science_room().

◆ place_items() [2/2]

std::vector< item * > map::place_items	(	const item_group_id &	loc,
		int	chance,
		point	p1,
		point	p2,
		bool	ongrass,
		const time_point &	turn,
		int	magazine = `0`,
		int	ammo = `0`
	)

inline

Definition at line 1309 of file map.h.

                                                                          {
            return place_items( loc, chance, tripoint( p1, abs_sub.z ), tripoint( p2, abs_sub.z ), ongrass,
                                turn, magazine, ammo );
        }

References abs_sub, place_items(), calendar::turn, and tripoint::z.

◆ place_npc()

character_id map::place_npc	(	point	p,
		const string_id< npc_template > &	type,
		bool	force = `false`
	)

Definition at line 5319 of file mapgen.cpp.

{
    if( !force && !get_option<bool>( "STATIC_NPC" ) ) {
        return character_id(); //Do not generate an npc.
    }
    shared_ptr_fast<npc> temp = make_shared_fast<npc>();
    temp->load_npc_template( type );
    temp->spawn_at_precise( { abs_sub.xy() }, { p, abs_sub.z } );
    temp->toggle_trait( trait_NPC_STATIC_NPC );
    overmap_buffer.insert_npc( temp );
    return temp->getID();
}

References abs_sub, character_id, overmapbuffer::insert_npc(), overmap_buffer, trait_NPC_STATIC_NPC, type, tripoint::xy(), and tripoint::z.

Referenced by jmapgen_npc::apply(), mapgen_hive(), MapExtras::mx_bandits_block(), MapExtras::mx_looters(), MapExtras::mx_marloss_pilgrimage(), and mission_start::ranch_nurse_9().

◆ place_spawns()

void map::place_spawns	(	const mongroup_id &	group,
		int	chance,
		point	p1,
		point	p2,
		float	density,
		bool	individual = `false`,
		bool	friendly = `false`,
		const std::string &	name = `"NONE"`,
		int	mission_id = `-1`
	)

Definition at line 5228 of file mapgen.cpp.

{
    if( !group.is_valid() ) {
        // TODO: fix point types
        const tripoint_abs_omt omt( sm_to_omt_copy( get_abs_sub() ) );
        const oter_id &oid = overmap_buffer.ter( omt );
        debugmsg( "place_spawns: invalid mongroup '%s', om_terrain = '%s' (%s)", group.c_str(),
                  oid.id().c_str(), oid->get_mapgen_id().c_str() );
        return;
    }
 
    // Set chance to be 1 or less to guarantee spawn, else set higher than 1
    if( !one_in( chance ) ) {
        return;
    }
 
    float spawn_density = 1.0f;
    if( MonsterGroupManager::is_animal( group ) ) {
        spawn_density = get_option< float >( "SPAWN_ANIMAL_DENSITY" );
    } else {
        spawn_density = get_option< float >( "SPAWN_DENSITY" );
    }
 
    float multiplier = density * spawn_density;
    // Only spawn 1 creature if individual flag set, else scale by density
    float thenum = individual ? 1 : ( multiplier * rng_float( 10.0f, 50.0f ) );
    int num = roll_remainder( thenum );
 
    // GetResultFromGroup decrements num
    while( num > 0 ) {
        int tries = 10;
        point p;
 
        // Pick a spot for the spawn
        do {
            p.x = rng( p1.x, p2.x );
            p.y = rng( p1.y, p2.y );
            tries--;
        } while( impassable( p ) && tries > 0 );
 
        // Pick a monster type
        MonsterGroupResult spawn_details = MonsterGroupManager::GetResultFromGroup( group, &num );
 
        add_spawn( spawn_details.name, spawn_details.pack_size, { p, abs_sub.z },
                   friendly, -1, mission_id, name );
    }
}

References add_spawn(), string_id< T >::c_str(), debugmsg, friendly, get_abs_sub(), oter_t::get_mapgen_id(), MonsterGroupManager::GetResultFromGroup(), int_id< T >::id(), impassable(), MonsterGroupManager::is_animal(), name(), MonsterGroupResult::name, num, coords::omt, one_in(), overmap_buffer, MonsterGroupResult::pack_size, rng(), rng_float(), roll_remainder(), sm_to_omt_copy(), overmapbuffer::ter(), point::x, and point::y.

Referenced by add_monsters(), jmapgen_monster_group::apply(), create_anomaly(), draw_lab(), draw_mine(), draw_office_tower(), draw_slimepit(), draw_temple(), draw_triffid(), mapgen_road(), MapExtras::mx_collegekids(), MapExtras::mx_corpses(), MapExtras::mx_drugdeal(), MapExtras::mx_military(), MapExtras::mx_pond(), MapExtras::mx_portal(), MapExtras::mx_portal_in(), MapExtras::mx_science(), and science_room().

◆ place_toilet()

void map::place_toilet	(	point	p,
		int	charges = `6 * 4`
	)

Definition at line 5291 of file mapgen.cpp.

{
    item water( "water", calendar::start_of_cataclysm );
    water.charges = charges;
    add_item( p, water );
    furn_set( p, f_toilet );
}

References add_item(), item::charges, f_toilet, furn_set(), and calendar::start_of_cataclysm.

Referenced by jmapgen_toilet::apply(), and mapf::formatted_set_simple().

◆ place_vending()

void map::place_vending	(	point	p,
		const item_group_id &	type,
		bool	reinforced = `false`
	)

Definition at line 5299 of file mapgen.cpp.

{
    if( reinforced ) {
        furn_set( p, f_vending_reinforced );
        place_items( type, 100, p, p, false, calendar::start_of_cataclysm );
    } else {
        if( one_in( 2 ) ) {
            furn_set( p, f_vending_o );
            for( const auto &loc : points_in_radius( { p, abs_sub.z }, 1 ) ) {
                if( one_in( 4 ) ) {
                    spawn_item( loc, "glass_shard", rng( 1, 2 ) );
                }
            }
        } else {
            furn_set( p, f_vending_c );
            place_items( type, 100, p, p, false, calendar::start_of_cataclysm );
        }
    }
}

References abs_sub, f_vending_c, f_vending_o, f_vending_reinforced, furn_set(), one_in(), place_items(), points_in_radius(), rng(), spawn_item(), calendar::start_of_cataclysm, type, and tripoint::z.

Referenced by jmapgen_vending_machine::apply().

◆ player_in_field()

void map::player_in_field ( player & u )

protected

Definition at line 1224 of file map_field.cpp.

{
    // A copy of the current field for reference. Do not add fields to it, use map::add_field
    field &curfield = get_field( u.pos() );
    // Are we inside?
    bool inside = false;
    // If we are in a vehicle figure out if we are inside (reduces effects usually)
    // and what part of the vehicle we need to deal with.
    if( u.in_vehicle ) {
        if( const optional_vpart_position vp = veh_at( u.pos() ) ) {
            inside = vp->is_inside();
        }
    }
 
    // Iterate through all field effects on this tile.
    // Do not remove the field with remove_field, instead set it's intensity to 0. It will be removed
    // later by the field processing, which will also adjust field_count accordingly.
    for( auto &field_list_it : curfield ) {
        field_entry &cur = field_list_it.second;
        if( !cur.is_field_alive() ) {
            continue;
        }
 
        // Do things based on what field effect we are currently in.
        const field_type_id ft = cur.get_field_type();
        if( ft == fd_web ) {
            // If we are in a web, can't walk in webs or are in a vehicle, get webbed maybe.
            // Moving through multiple webs stacks the effect.
            if( !u.has_trait( trait_WEB_WALKER ) && !u.in_vehicle ) {
                // Between 5 and 15 minus your current web level.
                u.add_effect( effect_webbed, 1_turns, num_bp, cur.get_field_intensity() );
                // It is spent.
                cur.set_field_intensity( 0 );
                continue;
                // If you are in a vehicle destroy the web.
                // It should of been destroyed when you ran over it anyway.
            } else if( u.in_vehicle ) {
                cur.set_field_intensity( 0 );
                continue;
            }
        }
        if( ft == fd_acid ) {
            // Assume vehicles block acid damage entirely,
            // you're certainly not standing in it.
            if( !u.in_vehicle && !u.has_trait( trait_ACIDPROOF ) ) {
                int total_damage = 0;
                total_damage += burn_body_part( u, cur, bp_foot_l, 2 );
                total_damage += burn_body_part( u, cur, bp_foot_r, 2 );
                const bool on_ground = u.is_on_ground();
                if( on_ground ) {
                    // Apply the effect to the remaining body parts
                    total_damage += burn_body_part( u, cur, bp_leg_l, 2 );
                    total_damage += burn_body_part( u, cur, bp_leg_r, 2 );
                    total_damage += burn_body_part( u, cur, bp_hand_l, 2 );
                    total_damage += burn_body_part( u, cur, bp_hand_r, 2 );
                    total_damage += burn_body_part( u, cur, bp_torso, 2 );
                    // Less arms = less ability to keep upright
                    if( ( !u.has_two_arms() && one_in( 4 ) ) || one_in( 2 ) ) {
                        total_damage += burn_body_part( u, cur, bp_arm_l, 1 );
                        total_damage += burn_body_part( u, cur, bp_arm_r, 1 );
                        total_damage += burn_body_part( u, cur, bp_head, 1 );
                    }
                }
 
                if( on_ground && total_damage > 0 ) {
                    u.add_msg_player_or_npc( m_bad, _( "The acid burns your body!" ),
                                             _( "The acid burns <npcname>s body!" ) );
                } else if( total_damage > 0 ) {
                    u.add_msg_player_or_npc( m_bad, _( "The acid burns your legs and feet!" ),
                                             _( "The acid burns <npcname>s legs and feet!" ) );
                } else if( on_ground ) {
                    u.add_msg_if_player( m_warning, _( "You're lying in a pool of acid" ) );
                } else {
                    u.add_msg_if_player( m_warning, _( "You're standing in a pool of acid" ) );
                }
 
                u.check_dead_state();
            }
        }
        if( ft == fd_sap ) {
            // Sap does nothing to cars.
            if( !u.in_vehicle ) {
                // Use up sap.
                cur.set_field_intensity( cur.get_field_intensity() - 1 );
            }
        }
        if( ft == fd_sludge ) {
            // Sludge is on the ground, but you are above the ground when boarded on a vehicle
            if( !u.in_vehicle ) {
                u.add_msg_if_player( m_bad, _( "The sludge is thick and sticky.  You struggle to pull free." ) );
                u.moves -= cur.get_field_intensity() * 300;
                cur.set_field_intensity( 0 );
            }
        }
        if( ft == fd_fire ) {
            // Heatsink or suit prevents ALL fire damage.
            if( !u.has_active_bionic( bio_heatsink ) && !u.is_wearing( itype_rm13_armor_on ) ) {
 
                // To modify power of a field based on... whatever is relevant for the effect.
                int adjusted_intensity = cur.get_field_intensity();
                // Burn the player. Less so if you are in a car or ON a car.
                if( u.in_vehicle ) {
                    if( inside ) {
                        adjusted_intensity -= 2;
                    } else {
                        adjusted_intensity -= 1;
                    }
                }
 
                if( adjusted_intensity >= 1 ) {
                    // Burn message by intensity
                    static const std::array<std::string, 4> player_burn_msg = { {
                            translate_marker( "You burn your legs and feet!" ),
                            translate_marker( "You're burning up!" ),
                            translate_marker( "You're set ablaze!" ),
                            translate_marker( "Your whole body is burning!" )
                        }
                    };
                    static const std::array<std::string, 4> npc_burn_msg = { {
                            translate_marker( "<npcname> burns their legs and feet!" ),
                            translate_marker( "<npcname> is burning up!" ),
                            translate_marker( "<npcname> is set ablaze!" ),
                            translate_marker( "<npcname>s whole body is burning!" )
                        }
                    };
                    static const std::array<std::string, 4> player_warn_msg = { {
                            translate_marker( "You're standing in a fire!" ),
                            translate_marker( "You're waist-deep in a fire!" ),
                            translate_marker( "You're surrounded by raging fire!" ),
                            translate_marker( "You're lying in fire!" )
                        }
                    };
 
                    const int burn_min = adjusted_intensity;
                    const int burn_max = 3 * adjusted_intensity + 3;
                    std::list<bodypart_id> parts_burned;
                    int msg_num = adjusted_intensity - 1;
                    if( !u.is_on_ground() ) {
                        switch( adjusted_intensity ) {
                            case 3:
                                parts_burned.push_back( bodypart_id( "hand_l" ) );
                                parts_burned.push_back( bodypart_id( "hand_r" ) );
                                parts_burned.push_back( bodypart_id( "arm_l" ) );
                                parts_burned.push_back( bodypart_id( "arm_r" ) );
                            /* fallthrough */
                            case 2:
                                parts_burned.push_back( bodypart_id( "torso" ) );
                            /* fallthrough */
                            case 1:
                                parts_burned.push_back( bodypart_id( "foot_l" ) );
                                parts_burned.push_back( bodypart_id( "foot_r" ) );
                                parts_burned.push_back( bodypart_id( "leg_l" ) );
                                parts_burned.push_back( bodypart_id( "leg_r" ) );
                        }
                    } else {
                        // Lying in the fire is BAAAD news, hits every body part.
                        msg_num = 3;
                        const std::vector<bodypart_id> &all_parts = u.get_all_body_parts();
                        // HACK: Skip num_bp part
                        for( auto bp : all_parts ) {
                            if( bp->token != num_bp ) {
                                parts_burned.push_back( bp );
                            }
                        }
                    }
 
                    int total_damage = 0;
                    for( const bodypart_id part_burned : parts_burned ) {
                        const dealt_damage_instance dealt = u.deal_damage( nullptr, part_burned,
                                                            damage_instance( DT_HEAT, rng( burn_min, burn_max ) ) );
                        total_damage += dealt.type_damage( DT_HEAT );
                    }
                    if( total_damage > 0 ) {
                        u.add_msg_player_or_npc( m_bad, _( player_burn_msg[msg_num] ), _( npc_burn_msg[msg_num] ) );
                    } else {
                        u.add_msg_if_player( m_warning, _( player_warn_msg[msg_num] ) );
                    }
                    u.check_dead_state();
                }
            }
 
        }
        if( ft == fd_tear_gas ) {
            // Tear gas will both give you teargas disease and/or blind you.
            if( ( cur.get_field_intensity() > 1 || !one_in( 3 ) ) && ( !inside || one_in( 3 ) ) ) {
                u.add_env_effect( effect_teargas, bp_mouth, 5, 20_seconds );
            }
            if( cur.get_field_intensity() > 1 && ( !inside || one_in( 3 ) ) ) {
                u.add_env_effect( effect_blind, bp_eyes, cur.get_field_intensity() * 2, 10_seconds );
            }
        }
        if( ft == fd_fungal_haze ) {
            if( !u.has_trait( trait_M_IMMUNE ) && ( !inside || one_in( 4 ) ) ) {
                u.add_env_effect( effect_fungus, bp_mouth, 4, 10_minutes, num_bp );
                u.add_env_effect( effect_fungus, bp_eyes, 4, 10_minutes, num_bp );
            }
        }
        if( ft == fd_dazzling ) {
            if( cur.get_field_intensity() > 1 || one_in( 5 ) ) {
                u.add_env_effect( effect_blind, bp_eyes, 10, 10_turns );
            } else {
                u.add_env_effect( effect_blind, bp_eyes, 2, 2_turns );
            }
        }
 
        if( cur.extra_radiation_min() > 0 ) {
            // Get irradiated by the nuclear fallout.
            const float rads = rng( cur.extra_radiation_min() + 1,
                                    cur.extra_radiation_max() * ( cur.extra_radiation_max() + 1 ) );
            const bool rad_proof = !u.irradiate( rads );
            // TODO: Reduce damage for rad resistant?
            if( cur.radiation_hurt_damage_min() > 0 && !rad_proof ) {
                u.add_msg_if_player( m_bad, cur.radiation_hurt_message() );
                u.hurtall( rng( cur.radiation_hurt_damage_min(), cur.radiation_hurt_damage_max() ), nullptr );
            }
        }
        if( ft == fd_flame_burst ) {
            // A burst of flame? Only hits the legs and torso.
            if( !inside ) {
                // Fireballs can't touch you inside a car.
                // Heatsink or suit stops fire.
                if( !u.has_active_bionic( bio_heatsink ) &&
                    !u.is_wearing( itype_rm13_armor_on ) ) {
                    u.add_msg_player_or_npc( m_bad, _( "You're torched by flames!" ),
                                             _( "<npcname> is torched by flames!" ) );
                    u.deal_damage( nullptr, bodypart_id( "leg_l" ), damage_instance( DT_HEAT, rng( 2, 6 ) ) );
                    u.deal_damage( nullptr, bodypart_id( "leg_r" ), damage_instance( DT_HEAT, rng( 2, 6 ) ) );
                    u.deal_damage( nullptr, bodypart_id( "torso" ), damage_instance( DT_HEAT, rng( 4, 9 ) ) );
                    u.check_dead_state();
                } else {
                    u.add_msg_player_or_npc( _( "These flames do not burn you." ),
                                             _( "Those flames do not burn <npcname>." ) );
                }
            }
        }
        if( ft == fd_electricity ) {
            // Small universal damage based on intensity, only if not electroproofed.
            if( !u.is_elec_immune() ) {
                int total_damage = 0;
                for( size_t i = 0; i < num_hp_parts; i++ ) {
                    const bodypart_id bp = convert_bp( player::hp_to_bp( static_cast<hp_part>( i ) ) ).id();
                    const int dmg = rng( 1, cur.get_field_intensity() );
                    total_damage += u.deal_damage( nullptr, bp, damage_instance( DT_ELECTRIC, dmg ) ).total_damage();
                }
 
                if( total_damage > 0 ) {
                    if( u.has_trait( trait_ELECTRORECEPTORS ) ) {
                        u.add_msg_player_or_npc( m_bad, _( "You're painfully electrocuted!" ),
                                                 _( "<npcname> is shocked!" ) );
                        u.mod_pain( total_damage / 2 );
                    } else {
                        u.add_msg_player_or_npc( m_bad, _( "You're shocked!" ), _( "<npcname> is shocked!" ) );
                    }
                } else {
                    u.add_msg_player_or_npc( _( "The electric cloud doesn't affect you." ),
                                             _( "The electric cloud doesn't seem to affect <npcname>." ) );
                }
            }
        }
        if( ft == fd_fatigue ) {
            // Assume the rift is on the ground for now to prevent issues with the player being unable access vehicle controls on the same tile due to teleportation.
            if( !u.in_vehicle ) {
                // Teleports you... somewhere.
                if( rng( 0, 2 ) < cur.get_field_intensity() && u.is_player() ) {
                    add_msg( m_bad, _( "You're violently teleported!" ) );
                    u.hurtall( cur.get_field_intensity(), nullptr );
                    teleport::teleport( u );
                }
            }
        }
        // Why do these get removed???
        // Stepping on a shock vent shuts it down.
        if( ft == fd_shock_vent || ft == fd_acid_vent ) {
            cur.set_field_intensity( 0 );
        }
        if( ft == fd_bees ) {
            // Player is immune to bees while underwater.
            if( !u.is_underwater() ) {
                const int intensity = cur.get_field_intensity();
                // Bees will try to sting you in random body parts, up to 8 times.
                for( int i = 0; i < rng( 1, 7 ); i++ ) {
                    bodypart_id bp = u.get_random_body_part();
                    int sum_cover = 0;
                    for( const item &i : u.worn ) {
                        if( i.covers( bp->token ) ) {
                            sum_cover += i.get_coverage();
                        }
                    }
                    // Get stung if [clothing on a body part isn't thick enough (like t-shirt) OR clothing covers less than 100% of body part]
                    // AND clothing on affected body part has low environmental protection value
                    if( ( u.get_armor_cut( bp ) <= 1 || ( sum_cover < 100 && x_in_y( 100 - sum_cover, 100 ) ) ) &&
                        u.add_env_effect( effect_stung, bp->token, intensity, 9_minutes ) ) {
                        u.add_msg_if_player( m_bad, _( "The bees sting you in %s!" ),
                                             body_part_name_accusative( bp->token ) );
                    }
                }
            }
        }
        if( ft == fd_incendiary ) {
            // Mysterious incendiary substance melts you horribly.
            if( u.has_trait( trait_M_SKIN2 ) ||
                u.has_trait( trait_M_SKIN3 ) ||
                cur.get_field_intensity() == 1 ) {
                u.add_msg_player_or_npc( m_bad, _( "The incendiary burns you!" ),
                                         _( "The incendiary burns <npcname>!" ) );
                u.hurtall( rng( 1, 3 ), nullptr );
            } else {
                u.add_msg_player_or_npc( m_bad, _( "The incendiary melts into your skin!" ),
                                         _( "The incendiary melts into <npcname>s skin!" ) );
                u.add_effect( effect_onfire, 8_turns, bp_torso );
                u.hurtall( rng( 2, 6 ), nullptr );
            }
        }
        // Both gases are unhealthy and become deadly if you cross a related threshold.
        if( ft == fd_fungicidal_gas || ft == fd_insecticidal_gas ) {
            // The gas won't harm you inside a vehicle.
            if( !inside ) {
                // Full body suits protect you from the effects of the gas.
                if( !( u.worn_with_flag( flag_GAS_PROOF ) && u.get_env_resist( bodypart_id( "mouth" ) ) >= 15 &&
                       u.get_env_resist( bodypart_id( "eyes" ) ) >= 15 ) ) {
                    const int intensity = cur.get_field_intensity();
                    bool inhaled = u.add_env_effect( effect_poison, bp_mouth, 5, intensity * 1_minutes );
                    if( u.has_trait( trait_THRESH_MYCUS ) || u.has_trait( trait_THRESH_MARLOSS ) ||
                        ( ft == fd_insecticidal_gas && ( u.get_highest_category() == "INSECT" ||
                                                         u.get_highest_category() == "SPIDER" ) ) ) {
                        inhaled |= u.add_env_effect( effect_badpoison, bp_mouth, 5, intensity * 1_minutes );
                        u.hurtall( rng( intensity, intensity * 2 ), nullptr );
                        u.add_msg_if_player( m_bad, _( "The %s burns your skin." ), cur.name() );
                    }
 
                    if( inhaled ) {
                        u.add_msg_if_player( m_bad, _( "The %s makes you feel sick." ), cur.name() );
                    }
                }
            }
        }
    }
}

References _, Creature::add_effect(), Creature::add_env_effect(), add_msg(), player::add_msg_if_player(), player::add_msg_player_or_npc(), bio_heatsink, body_part_name_accusative(), bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, burn_body_part(), Creature::check_dead_state(), convert_bp(), item::covers(), Character::deal_damage(), DT_ELECTRIC, DT_HEAT, effect_badpoison, effect_blind, effect_fungus, effect_onfire, effect_poison, effect_stung, effect_teargas, effect_webbed, field_entry::extra_radiation_max(), field_entry::extra_radiation_min(), fd_acid, fd_acid_vent, fd_bees, fd_dazzling, fd_electricity, fd_fatigue, fd_fire, fd_flame_burst, fd_fungal_haze, fd_fungicidal_gas, fd_incendiary, fd_insecticidal_gas, fd_sap, fd_shock_vent, fd_sludge, fd_tear_gas, fd_web, flag_GAS_PROOF(), Creature::get_all_body_parts(), Character::get_armor_cut(), item::get_coverage(), Character::get_env_resist(), get_field(), field_entry::get_field_intensity(), field_entry::get_field_type(), Character::get_highest_category(), Creature::get_random_body_part(), Character::has_active_bionic(), Character::has_trait(), Character::has_two_arms(), Character::hp_to_bp(), Character::hurtall(), string_id< T >::id(), Character::in_vehicle, Character::irradiate(), Character::is_elec_immune(), field_entry::is_field_alive(), Character::is_on_ground(), player::is_player(), Creature::is_underwater(), Character::is_wearing(), itype_rm13_armor_on, m_bad, m_warning, Character::mod_pain(), Creature::moves, field_entry::name(), num_bp, num_hp_parts, one_in(), Character::pos(), field_entry::radiation_hurt_damage_max(), field_entry::radiation_hurt_damage_min(), field_entry::radiation_hurt_message(), rng(), field_entry::set_field_intensity(), teleport::teleport(), dealt_damage_instance::total_damage(), trait_ACIDPROOF, trait_ELECTRORECEPTORS, trait_M_IMMUNE, trait_M_SKIN2, trait_M_SKIN3, trait_THRESH_MARLOSS, trait_THRESH_MYCUS, trait_WEB_WALKER, translate_marker, dealt_damage_instance::type_damage(), veh_at(), Character::worn, Character::worn_with_flag(), and x_in_y().

Referenced by creature_in_field().

◆ point_within_camp()

bool map::point_within_camp ( const tripoint & point_check ) const

Definition at line 5693 of file map.cpp.

{
    // TODO: fix point types
    const tripoint_abs_omt omt_check( ms_to_omt_copy( point_check ) );
    const point_abs_omt p = omt_check.xy();
    for( int x2 = -2; x2 < 2; x2++ ) {
        for( int y2 = -2; y2 < 2; y2++ ) {
            if( std::optional<basecamp *> bcp = overmap_buffer.find_camp( p + point( x2, y2 ) ) ) {
                return ( *bcp )->camp_omt_pos().z() == point_check.z;
            }
        }
    }
    return false;
}

References overmapbuffer::find_camp(), ms_to_omt_copy(), overmap_buffer, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::z.

◆ points_in_radius()

tripoint_range< tripoint > map::points_in_radius	(	const tripoint &	center,
		size_t	radius,
		size_t	radiusz = `0`
	)		const

Definition at line 8762 of file map.cpp.

{
    const tripoint min( std::max<int>( 0, center.x - radius ), std::max<int>( 0, center.y - radius ),
                        clamp<int>( center.z - radiusz, -OVERMAP_DEPTH, OVERMAP_HEIGHT ) );
    const tripoint max( std::min<int>( SEEX * my_MAPSIZE - 1, center.x + radius ),
                        std::min<int>( SEEX * my_MAPSIZE - 1, center.y + radius ), clamp<int>( center.z + radiusz,
                                -OVERMAP_DEPTH, OVERMAP_HEIGHT ) );
    return tripoint_range<tripoint>( min, max );
}

References center, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, and SEEX.

Referenced by add_splash(), bash_furn_success(), climb_difficulty(), collapse_at(), collapse_check(), game::control_vehicle(), displace_water(), computer_session::failure_manhacks(), computer_session::failure_secubots(), find_furnitures_or_vparts_with_flag_in_radius(), find_furnitures_with_flag_in_radius(), find_potential_computer_point(), game::forced_door_closing(), basecamp::form_crafting_inventory(), inventory::form_from_map(), get_creatures_in_radius(), has_adjacent_furniture_with(), has_nearby_chair(), has_nearby_fire(), has_nearby_table(), is_cornerfloor(), is_wall_adjacent(), map_funcs::migo_nerve_cage_removal(), game::monmove(), MapExtras::mx_casings(), MapExtras::mx_corpses(), MapExtras::mx_looters(), MapExtras::mx_marloss_pilgrimage(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), MapExtras::mx_portal(), MapExtras::mx_portal_in(), trap::on_disarmed(), game::place_critter_around(), mission_start::place_deposit_box(), game::place_player(), place_vending(), game::process_artifact(), process_fields_in_submap(), propagate_suspension_check(), avatar_action::ramp_move(), reachable_flood_steps(), spawn_monsters_submap(), spread_gas(), use_amount(), and game::vertical_move().

◆ points_in_rectangle()

tripoint_range< tripoint > map::points_in_rectangle	(	const tripoint &	from,
		const tripoint &	to
	)		const

Definition at line 8752 of file map.cpp.

{
    const tripoint min( std::max( 0, std::min( from.x, to.x ) ), std::max( 0, std::min( from.y,
                        to.y ) ), std::max( -OVERMAP_DEPTH, std::min( from.z, to.z ) ) );
    const tripoint max( std::min( SEEX * my_MAPSIZE - 1, std::max( from.x, to.x ) ),
                        std::min( SEEX * my_MAPSIZE - 1, std::max( from.y, to.y ) ), std::min( OVERMAP_HEIGHT,
                                std::max( from.z, to.z ) ) );
    return tripoint_range<tripoint>( min, max );
}

References my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, SEEX, tripoint::x, tripoint::y, and tripoint::z.

Referenced by apply_faction_ownership(), debug_menu::debug(), draw_lab(), draw_mine(), farm_action(), game::find_or_make_stairs(), generate_lightmap(), jmapgen_setmap::has_vehicle_collision(), avatar_action::move(), MapExtras::mx_portal(), om_cutdown_trees(), om_harvest_furn(), om_harvest_itm(), and om_harvest_ter().

◆ points_on_zlevel() [1/2]

tripoint_range< tripoint > map::points_on_zlevel ( ) const

Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub).

Definition at line 8783 of file map.cpp.

{
    return points_on_zlevel( abs_sub.z );
}

References abs_sub, points_on_zlevel(), and tripoint::z.

Referenced by start_location::burn(), editmap::draw_main_ui_overlay(), talk_function::field_harvest(), talk_function::field_plant(), find_potential_computer_point(), find_valid_teleporters_omt(), get_changed_ids_from_update(), talk_function::loot_building(), Character::place_corpse(), mission_start::place_deposit_box(), mission_start::place_priest_diary(), points_on_zlevel(), start_location::prepare_map(), random_outdoor_tile(), resolve_regional_terrain_and_furniture(), mission_start::reveal_lab_train_depot(), translate(), translate_radius(), and game::update_stair_monsters().

◆ points_on_zlevel() [2/2]

tripoint_range< tripoint > map::points_on_zlevel ( int z ) const

Same as above, but uses the specific z-level.

If the given z-level is invalid, it returns an empty range.

Definition at line 8773 of file map.cpp.

{
    if( z < -OVERMAP_DEPTH || z > OVERMAP_HEIGHT ) {
        // TODO: need a default constructor that creates an empty range.
        return tripoint_range<tripoint>( tripoint_zero, tripoint_zero - tripoint_above );
    }
    return tripoint_range<tripoint>(
               tripoint( 0, 0, z ), tripoint( SEEX * my_MAPSIZE - 1, SEEY * my_MAPSIZE - 1, z ) );
}

References my_MAPSIZE, OVERMAP_HEIGHT, SEEX, SEEY, tripoint_above, and tripoint_zero.

◆ process_falling()

void map::process_falling ( )

Invoked drop_everything on cached dirty tiles.

Definition at line 2356 of file map.cpp.

{
    if( !zlevels ) {
        support_cache_dirty.clear();
        return;
    }
 
    if( !support_cache_dirty.empty() ) {
        add_msg( m_debug, "Checking %d tiles for falling objects",
                 support_cache_dirty.size() );
        // We want the cache to stay constant, but falling can change it
        std::set<tripoint> last_cache = std::move( support_cache_dirty );
        support_cache_dirty.clear();
        for( const tripoint &p : last_cache ) {
            drop_everything( p );
        }
    }
}

References add_msg(), drop_everything(), m_debug, avatar_action::move(), support_cache_dirty, and zlevels.

Referenced by game::do_turn().

◆ process_fields()

void map::process_fields ( )

Definition at line 142 of file map_field.cpp.

{
    const int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int z = minz; z <= maxz; z++ ) {
        auto &field_cache = get_cache( z ).field_cache;
        for( int x = 0; x < my_MAPSIZE; x++ ) {
            for( int y = 0; y < my_MAPSIZE; y++ ) {
                if( field_cache[ x + y * MAPSIZE ] ) {
                    submap *const current_submap = get_submap_at_grid( { x, y, z } );
                    process_fields_in_submap( current_submap, tripoint( x, y, z ) );
                }
            }
        }
 
        // no need to invalidate "transparency" and "seen" caches here
        // they are invalidated point by point inside the `process_fields_in_submap`
    }
}

References abs_sub, level_cache::field_cache, get_cache(), get_submap_at_grid(), MAPSIZE, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, process_fields_in_submap(), tripoint::z, and zlevels.

Referenced by game::do_turn().

◆ process_fields_in_submap()

void map::process_fields_in_submap	(	submap *	current_submap,
		const tripoint &	submap_pos
	)

Definition at line 397 of file map_field.cpp.

{
    scent_block sblk( submap, g->scent );
 
    // Holds m.field_at(x,y).find_field(fd_some_field) type returns.
    // Just to avoid typing that long string for a temp value.
    field_entry *tmpfld = nullptr;
 
    map &here = get_map();
    tripoint thep;
    thep.z = submap.z;
 
    // Initialize the map tile wrapper
    maptile map_tile( current_submap, point_zero );
    int &locx = map_tile.pos_.x;
    int &locy = map_tile.pos_.y;
    const point sm_offset( submap.x * SEEX, submap.y * SEEY );
 
    // Loop through all tiles in this submap indicated by current_submap
    for( locx = 0; locx < SEEX; locx++ ) {
        for( locy = 0; locy < SEEY; locy++ ) {
            // Get a reference to the field variable from the submap;
            // contains all the pointers to the real field effects.
            field &curfield = current_submap->get_field( { static_cast<int>( locx ), static_cast<int>( locy ) } );
 
            // when displayed_field_type == fd_null it means that `curfield` has no fields inside
            // avoids instantiating (relatively) expensive map iterator
            if( !curfield.displayed_field_type() ) {
                continue;
            }
 
            // This is a translation from local coordinates to submap coordinates.
            // All submaps are in one long 1d array.
            thep.x = locx + sm_offset.x;
            thep.y = locy + sm_offset.y;
            // A const reference to the tripoint above, so that the code below doesn't accidentally change it
            const tripoint &p = thep;
 
            // This should be true only when the field in the current tile changes transparency state,
            // More correctly: not just when the field is opaque, but when it changes state
            // to a more/less transparent one
            bool dirty_transparency_cache = false;
 
            for( auto it = curfield.begin(); it != curfield.end(); ) {
                // Iterating through all field effects in the submap's field.
                field_entry &cur = it->second;
 
                // Holds cur.get_field_type() as that is what the old system used before rewrite.
                field_type_id cur_fd_type_id = cur.get_field_type();
 
                // The field might have been killed by processing a neighbor field
                if( !cur.is_field_alive() ) {
                    if( !cur_fd_type_id->get_transparent( cur.get_field_intensity() - 1 ) ) {
                        dirty_transparency_cache = true;
                    }
                    --current_submap->field_count;
                    curfield.remove_field( it++ );
                    continue;
                }
 
                // Again, legacy support in the event someone Mods set_field_intensity to allow more values.
                if( cur.get_field_intensity() > 3 || cur.get_field_intensity() < 1 ) {
                    // TODO: Remove this eventually as we would suppoort more than 3 field intensity levels
                    debugmsg( "Whoooooa intensity of %d", cur.get_field_intensity() );
                }
 
                dirty_transparency_cache |= cur_fd_type_id->dirty_transparency_cache;
 
                // Don't process "newborn" fields. This gives the player time to run if they need to.
                if( cur.get_field_age() == 0_turns ) {
                    cur_fd_type_id = fd_null;
                }
 
                const field_type &cur_fd_type = *cur_fd_type_id;
 
                // Upgrade field intensity
                if( cur.intensity_upgrade_chance() > 0 &&
                    one_in( cur.intensity_upgrade_chance() ) &&
                    cur.intensity_upgrade_duration() > 0_turns &&
                    calendar::once_every( cur.intensity_upgrade_duration() ) ) {
                    cur.set_field_intensity( cur.get_field_intensity() + 1 );
                }
 
                int part;
                const ter_t &ter = map_tile.get_ter_t();
                // Dissipate faster in water
                if( ter.has_flag( TFLAG_SWIMMABLE ) ) {
                    cur.mod_field_age( cur.get_underwater_age_speedup() );
                }
                if( cur_fd_type_id == fd_acid ) {
                    // Try to fall by a z-level
                    if( zlevels && p.z > -OVERMAP_DEPTH ) {
                        tripoint dst{ p.xy(), p.z - 1 };
                        if( valid_move( p, dst, true, true ) ) {
                            field_entry *acid_there = field_at( dst ).find_field( fd_acid );
                            if( acid_there == nullptr ) {
                                add_field( dst, fd_acid, cur.get_field_intensity(), cur.get_field_age() );
                            } else {
                                // Math can be a bit off,
                                // but "boiling" falling acid can be allowed to be stronger
                                // than acid that just lies there
                                const int sum_intensity = cur.get_field_intensity() + acid_there->get_field_intensity();
                                const int new_intensity = std::min( 3, sum_intensity );
                                // No way to get precise elapsed time, let's always reset
                                // Allow falling acid to last longer than regular acid to show it off
                                const time_duration new_age = -1_minutes * ( sum_intensity - new_intensity );
                                acid_there->set_field_intensity( new_intensity );
                                acid_there->set_field_age( new_age );
                            }
 
                            // Set ourselves up for removal
                            cur.set_field_intensity( 0 );
                        }
                    }
                    // TODO: Allow spreading to the sides if age < 0 && intensity == 3
                }
                if( cur_fd_type.apply_slime_factor > 0 ) {
                    sblk.apply_slime( p, cur.get_field_intensity() * cur_fd_type.apply_slime_factor );
                }
                if( cur_fd_type_id == fd_fire ) {
                    cur.set_field_age( std::max( -24_hours, cur.get_field_age() ) );
                    // Entire objects for ter/frn for flags
                    const ter_t &ter = map_tile.get_ter_t();
                    const furn_t &frn = map_tile.get_furn_t();
 
                    // We've got ter/furn cached, so let's use that
                    const bool is_sealed = ter_furn_has_flag( ter, frn, TFLAG_SEALED ) &&
                                           !ter_furn_has_flag( ter, frn, TFLAG_ALLOW_FIELD_EFFECT );
                    // Consumed items count
                    int consumed = 0;
                    // How much time to add to the fire's life due to burned items/terrain/furniture
                    time_duration time_added = 0_turns;
                    // Checks if the fire can spread
                    const bool can_spread = !ter_furn_has_flag( ter, frn, TFLAG_FIRE_CONTAINER );
                    const bool no_floor = ter.has_flag( TFLAG_NO_FLOOR );
                    // If the flames are in furniture with fire_container flag like brazier or oven,
                    // they're fully contained, so skip consuming terrain
                    const bool can_burn = !no_floor && can_spread &&
                                          ( check_flammable( ter ) || check_flammable( frn ) );
                    // The huge indent below should probably be somehow moved away from here
                    // without forcing the function to use i_at( p ) for fires without items
                    if( !is_sealed && map_tile.get_item_count() > 0 ) {
                        map_stack items_here = i_at( p );
                        std::vector<item> new_content;
                        for( auto explosive = items_here.begin(); explosive != items_here.end(); ) {
                            if( explosive->will_explode_in_fire() ) {
                                // We need to make a copy because the iterator validity is not predictable
                                item copy = *explosive;
                                explosive = items_here.erase( explosive );
                                if( copy.detonate( p, new_content ) ) {
                                    // Need to restart, iterators may not be valid
                                    explosive = items_here.begin();
                                }
                            } else {
                                ++explosive;
                            }
                        }
 
                        fire_data frd( cur.get_field_intensity(), !can_spread );
                        // The highest # of items this fire can remove in one turn
                        int max_consume = cur.get_field_intensity() * 2;
 
                        for( auto fuel = items_here.begin(); fuel != items_here.end() && consumed < max_consume; ) {
                            // `item::burn` modifies the charges in order to simulate some of them getting
                            // destroyed by the fire, this changes the item weight, but may not actually
                            // destroy it. We need to spawn products anyway.
                            const units::mass old_weight = fuel->weight( false );
                            bool destroyed = fuel->burn( frd );
                            // If the item is considered destroyed, it may have negative charge count,
                            // see `item::burn?. This in turn means `item::weight` returns a negative value,
                            // which we can not use, so only call `weight` when it's still an existing item.
                            const units::mass new_weight = destroyed ? 0_gram : fuel->weight( false );
                            if( old_weight != new_weight ) {
                                create_burnproducts( p, *fuel, old_weight - new_weight );
                            }
 
                            if( destroyed ) {
                                // If we decided the item was destroyed by fire, remove it.
                                // But remember its contents, except for irremovable mods, if any
                                const std::list<item *> content_list = fuel->contents.all_items_top();
                                for( item *it : content_list ) {
                                    if( !it->is_irremovable() ) {
                                        new_content.push_back( item( *it ) );
                                    }
                                }
                                fuel = items_here.erase( fuel );
                                consumed++;
                            } else {
                                ++fuel;
                            }
                        }
 
                        spawn_items( p, new_content );
                        time_added = 1_turns * roll_remainder( frd.fuel_produced );
                    }
 
                    // Get the part of the vehicle in the fire (_internal skips the boundary check)
                    vehicle *veh = veh_at_internal( p, part );
                    if( veh != nullptr ) {
                        veh->damage( part, cur.get_field_intensity() * 10, DT_HEAT, true );
                        // Damage the vehicle in the fire.
                    }
                    if( can_burn ) {
                        if( ter.has_flag( TFLAG_SWIMMABLE ) ) {
                            // Flames die quickly on water
                            cur.set_field_age( cur.get_field_age() + 4_minutes );
                        }
 
                        // Consume the terrain we're on
                        if( ter_furn_has_flag( ter, frn, TFLAG_FLAMMABLE ) ) {
                            // The fire feeds on the ground itself until max intensity.
                            time_added += 1_turns * ( 5 - cur.get_field_intensity() );
                            if( cur.get_field_intensity() > 1 &&
                                one_in( 200 - cur.get_field_intensity() * 50 ) ) {
                                destroy( p, false );
                            }
 
                        } else if( ter_furn_has_flag( ter, frn, TFLAG_FLAMMABLE_HARD ) &&
                                   one_in( 3 ) ) {
                            // The fire feeds on the ground itself until max intensity.
                            time_added += 1_turns * ( 4 - cur.get_field_intensity() );
                            if( cur.get_field_intensity() > 1 &&
                                one_in( 200 - cur.get_field_intensity() * 50 ) ) {
                                destroy( p, false );
                            }
 
                        } else if( ter.has_flag( TFLAG_FLAMMABLE_ASH ) ) {
                            // The fire feeds on the ground itself until max intensity.
                            time_added += 1_turns * ( 5 - cur.get_field_intensity() );
                            if( cur.get_field_intensity() > 1 &&
                                one_in( 200 - cur.get_field_intensity() * 50 ) ) {
                                if( p.z > 0 ) {
                                    // We're in the air
                                    ter_set( p, t_open_air );
                                } else {
                                    ter_set( p, t_dirt );
                                }
                            }
 
                        } else if( frn.has_flag( TFLAG_FLAMMABLE_ASH ) ) {
                            // The fire feeds on the ground itself until max intensity.
                            time_added += 1_turns * ( 5 - cur.get_field_intensity() );
                            if( cur.get_field_intensity() > 1 &&
                                one_in( 200 - cur.get_field_intensity() * 50 ) ) {
                                furn_set( p, f_ash );
                            }
 
                        }
                    }
 
                    if( ter.has_flag( TFLAG_NO_FLOOR ) && zlevels && p.z > -OVERMAP_DEPTH ) {
                        // We're hanging in the air - let's fall down
                        tripoint dst{ p.xy(), p.z - 1 };
                        if( valid_move( p, dst, true, true ) ) {
                            maptile dst_tile = maptile_at_internal( dst );
                            field_entry *fire_there = dst_tile.find_field( fd_fire );
                            if( fire_there == nullptr ) {
                                add_field( dst, fd_fire, 1, 0_turns, false );
                                cur.set_field_intensity( cur.get_field_intensity() - 1 );
                            } else {
                                // Don't fuel raging fires or they'll burn forever
                                // as they can produce small fires above themselves
                                int new_intensity = std::max( cur.get_field_intensity(),
                                                              fire_there->get_field_intensity() );
                                // Allow smaller fires to combine
                                if( new_intensity < 3 &&
                                    cur.get_field_intensity() == fire_there->get_field_intensity() ) {
                                    new_intensity++;
                                }
                                // A raging fire below us can support us for a while
                                // Otherwise decay and decay fast
                                if( fire_there->get_field_intensity() < 3 || one_in( 10 ) ) {
                                    cur.set_field_intensity( cur.get_field_intensity() - 1 );
                                }
                                fire_there->set_field_intensity( new_intensity );
                            }
                            break;
                        }
                    }
                    // Lower age is a longer lasting fire
                    if( time_added != 0_turns ) {
                        cur.set_field_age( cur.get_field_age() - time_added );
                    } else if( can_burn ) {
                        // Nothing to burn = fire should be dying out faster
                        // Drain more power from big fires, so that they stop raging over nothing
                        // Except for fires on stoves and fireplaces, those are made to keep the fire alive
                        cur.mod_field_age( 10_seconds * cur.get_field_intensity() );
                    }
 
                    // Allow raging fires (and only raging fires) to spread up
                    // Spreading down is achieved by wrecking the walls/floor and then falling
                    if( zlevels && cur.get_field_intensity() == 3 && p.z < OVERMAP_HEIGHT ) {
                        const tripoint dst_p = tripoint( p.xy(), p.z + 1 );
                        // Let it burn through the floor
                        maptile dst = maptile_at_internal( dst_p );
                        const auto &dst_ter = dst.get_ter_t();
                        if( dst_ter.has_flag( TFLAG_NO_FLOOR ) ||
                            dst_ter.has_flag( TFLAG_FLAMMABLE ) ||
                            dst_ter.has_flag( TFLAG_FLAMMABLE_ASH ) ||
                            dst_ter.has_flag( TFLAG_FLAMMABLE_HARD ) ) {
                            field_entry *nearfire = dst.find_field( fd_fire );
                            if( nearfire != nullptr ) {
                                nearfire->mod_field_age( -2_turns );
                            } else {
                                add_field( dst_p, fd_fire, 1, 0_turns, false );
                            }
                            // Fueling fires above doesn't cost fuel
                        }
                    }
 
                    // Below we will access our nearest 8 neighbors, so let's cache them now
                    // This should probably be done more globally, because large fires will re-do it a lot
                    auto neighs = get_neighbors( p );
 
                    // If the flames are in a pit, it can't spread to non-pit
                    const bool in_pit = can_spread && ter.id.id() == t_pit;
 
                    // Count adjacent fires, to optimize out needless smoke and hot air
                    int adjacent_fires = 0;
 
                    // If the flames are big, they contribute to adjacent flames
                    if( can_spread ) {
                        if( cur.get_field_intensity() > 1 && one_in( 3 ) ) {
                            // Basically: Scan around for a spot,
                            // if there is more fire there, make it bigger and give it some fuel.
                            // This is how big fires spend their excess age:
                            // making other fires bigger. Flashpoint.
                            size_t end_it = static_cast<size_t>( rng( 0, neighs.size() - 1 ) );
                            for( size_t i = ( end_it + 1 ) % neighs.size(), count = 0;
                                 count != neighs.size() && cur.get_field_age() < 0_turns;
                                 i = ( i + 1 ) % neighs.size(), count++ ) {
                                maptile &dst = neighs[i].second;
                                auto dstfld = dst.find_field( fd_fire );
                                // If the fire exists and is weaker than ours, boost it
                                if( dstfld != nullptr &&
                                    ( dstfld->get_field_intensity() <= cur.get_field_intensity() ||
                                      dstfld->get_field_age() > cur.get_field_age() ) &&
                                    ( in_pit == ( dst.get_ter() == t_pit ) ) ) {
                                    if( dstfld->get_field_intensity() < 2 ) {
                                        dstfld->set_field_intensity( dstfld->get_field_intensity() + 1 );
                                    }
 
                                    dstfld->set_field_age( dstfld->get_field_age() - 5_minutes );
                                    cur.set_field_age( cur.get_field_age() + 5_minutes );
                                }
                                if( dstfld != nullptr ) {
                                    adjacent_fires++;
                                }
                            }
                        } else if( cur.get_field_age() < 0_turns && cur.get_field_intensity() < 3 ) {
                            // See if we can grow into a stage 2/3 fire, for this
                            // burning neighbors are necessary in addition to
                            // field age < 0, or alternatively, a LOT of fuel.
 
                            // The maximum fire intensity is 1 for a lone fire, 2 for at least 1 neighbor,
                            // 3 for at least 2 neighbors.
                            int maximum_intensity = 1;
 
                            // The following logic looks a bit complex due to optimization concerns, so here are the semantics:
                            // 1. Calculate maximum field intensity based on fuel, -50 minutes is 2(medium), -500 minutes is 3(raging)
                            // 2. Calculate maximum field intensity based on neighbors, 3 neighbors is 2(medium), 7 or more neighbors is 3(raging)
                            // 3. Pick the higher maximum between 1. and 2.
                            if( cur.get_field_age() < -500_minutes ) {
                                maximum_intensity = 3;
                            } else {
                                for( auto &neigh : neighs ) {
                                    if( neigh.second.get_field().find_field( fd_fire ) != nullptr ) {
                                        adjacent_fires++;
                                    }
                                }
                                maximum_intensity = 1 + ( adjacent_fires >= 3 ) + ( adjacent_fires >= 7 );
 
                                if( maximum_intensity < 2 && cur.get_field_age() < -50_minutes ) {
                                    maximum_intensity = 2;
                                }
                            }
 
                            // If we consumed a lot, the flames grow higher
                            if( cur.get_field_intensity() < maximum_intensity && cur.get_field_age() < 0_turns ) {
                                // Fires under 0 age grow in size. Level 3 fires under 0 spread later on.
                                // Weaken the newly-grown fire
                                cur.set_field_intensity( cur.get_field_intensity() + 1 );
                                cur.set_field_age( cur.get_field_age() + 10_minutes * cur.get_field_intensity() );
                            }
                        }
 
                        // Consume adjacent fuel / terrain / webs to spread.
                        // Our iterator will start at end_i + 1 and increment from there and then wrap around.
                        // This guarantees it will check all neighbors, starting from a random one
                        const size_t end_i = static_cast<size_t>( rng( 0, neighs.size() - 1 ) );
                        for( size_t i = ( end_i + 1 ) % neighs.size(), count = 0;
                             count != neighs.size();
                             i = ( i + 1 ) % neighs.size(), count++ ) {
                            if( one_in( cur.get_field_intensity() * 2 ) ) {
                                // Skip some processing to save on CPU
                                continue;
                            }
 
                            tripoint &dst_p = neighs[i].first;
                            maptile &dst = neighs[i].second;
                            // No bounds checking here: we'll treat the invalid neighbors as valid.
                            // We're using the map tile wrapper, so we can treat invalid tiles as sentinels.
                            // This will create small oddities on map edges, but nothing more noticeable than
                            // "cut-off" that happens with bounds checks.
 
                            field_entry *nearfire = dst.find_field( fd_fire );
                            if( nearfire != nullptr ) {
                                // We handled supporting fires in the section above, no need to do it here
                                continue;
                            }
 
                            field_entry *nearwebfld = dst.find_field( fd_web );
                            int spread_chance = 25 * ( cur.get_field_intensity() - 1 );
                            if( nearwebfld != nullptr ) {
                                spread_chance = 50 + spread_chance / 2;
                            }
 
                            const ter_t &dster = dst.get_ter_t();
                            const furn_t &dsfrn = dst.get_furn_t();
                            // Allow weaker fires to spread occasionally
                            const int power = cur.get_field_intensity() + one_in( 5 );
                            if( can_spread && rng( 1, 100 ) < spread_chance &&
                                ( check_flammable( dster ) || check_flammable( dsfrn ) ) &&
                                ( in_pit == ( dster.id.id() == t_pit ) ) &&
                                (
                                    ( power >= 3 && cur.get_field_age() < 0_turns && one_in( 20 ) ) ||
                                    ( power >= 2 && ( ter_furn_has_flag( dster, dsfrn, TFLAG_FLAMMABLE ) && one_in( 2 ) ) ) ||
                                    ( power >= 2 && ( ter_furn_has_flag( dster, dsfrn, TFLAG_FLAMMABLE_ASH ) && one_in( 2 ) ) ) ||
                                    ( power >= 3 && ( ter_furn_has_flag( dster, dsfrn, TFLAG_FLAMMABLE_HARD ) && one_in( 5 ) ) ) ||
                                    nearwebfld || ( dst.get_item_count() > 0 &&
                                                    flammable_items_at( p + eight_horizontal_neighbors[i] ) &&
                                                    one_in( 5 ) )
                                ) ) {
                                // Nearby open flammable ground? Set it on fire.
                                add_field( dst_p, fd_fire, 1, 0_turns, false );
                                tmpfld = dst.find_field( fd_fire );
                                if( tmpfld != nullptr ) {
                                    // Make the new fire quite weak, so that it doesn't start jumping around instantly
                                    tmpfld->set_field_age( 2_minutes );
                                    // Consume a bit of our fuel
                                    cur.set_field_age( cur.get_field_age() + 1_minutes );
                                }
                                if( nearwebfld ) {
                                    nearwebfld->set_field_intensity( 0 );
                                }
                            }
                        }
                    }
                }
 
                // Spread gaseous fields
                if( cur.gas_can_spread() ) {
                    const int gas_percent_spread = cur_fd_type.percent_spread;
                    if( gas_percent_spread > 0 ) {
                        const time_duration outdoor_age_speedup = cur_fd_type.outdoor_age_speedup;
                        spread_gas( cur, p, gas_percent_spread, outdoor_age_speedup, sblk );
                    }
                }
 
                if( cur_fd_type_id == fd_fungal_haze ) {
                    if( one_in( 10 - 2 * cur.get_field_intensity() ) ) {
                        // Haze'd terrain
                        fungal_effects( *g, here ).spread_fungus( p );
                    }
                }
 
                // Process npc complaints
                const std::tuple<int, std::string, time_duration, std::string> &npc_complain_data =
                    cur_fd_type.npc_complain_data;
                const int chance = std::get<0>( npc_complain_data );
                if( chance > 0 && one_in( chance ) ) {
                    if( npc *const np = g->critter_at<npc>( p, false ) ) {
                        np->complain_about( std::get<1>( npc_complain_data ),
                                            std::get<2>( npc_complain_data ),
                                            std::get<3>( npc_complain_data ) );
                    }
                }
 
                // Apply radiation
                if( cur.extra_radiation_max() > 0 ) {
                    int extra_radiation = rng( cur.extra_radiation_min(), cur.extra_radiation_max() );
                    adjust_radiation( p, extra_radiation );
                }
 
                // Apply wandering fields from vents
                if( cur_fd_type.wandering_field ) {
                    for( const tripoint &pnt : points_in_radius( p, cur.get_field_intensity() - 1 ) ) {
                        field &wandering_field = get_field( pnt );
                        tmpfld = wandering_field.find_field( cur_fd_type.wandering_field );
                        if( tmpfld && tmpfld->get_field_intensity() < cur.get_field_intensity() ) {
                            tmpfld->set_field_intensity( tmpfld->get_field_intensity() + 1 );
                        } else {
                            add_field( pnt, cur_fd_type.wandering_field, cur.get_field_intensity() );
                        }
                    }
                }
 
                if( cur_fd_type_id == fd_fire_vent ) {
 
                    if( cur.get_field_intensity() > 1 ) {
                        if( one_in( 3 ) ) {
                            cur.set_field_intensity( cur.get_field_intensity() - 1 );
                        }
                        create_hot_air( p, cur.get_field_intensity() );
                    } else {
                        dirty_transparency_cache = true;
                        add_field( p, fd_flame_burst, 3, cur.get_field_age() );
                        cur.set_field_intensity( 0 );
                    }
                }
                if( cur_fd_type_id == fd_flame_burst ) {
                    if( cur.get_field_intensity() > 1 ) {
                        cur.set_field_intensity( cur.get_field_intensity() - 1 );
                        create_hot_air( p, cur.get_field_intensity() );
                    } else {
                        dirty_transparency_cache = true;
                        add_field( p, fd_fire_vent, 3, cur.get_field_age() );
                        cur.set_field_intensity( 0 );
                    }
                }
                if( cur_fd_type_id == fd_electricity ) {
                    // 4 in 5 chance to spread
                    if( !one_in( 5 ) ) {
                        std::vector<tripoint> valid;
                        // We're grounded
                        if( impassable( p ) && cur.get_field_intensity() > 1 ) {
                            int tries = 0;
                            tripoint pnt;
                            pnt.z = p.z;
                            while( tries < 10 && cur.get_field_age() < 5_minutes && cur.get_field_intensity() > 1 ) {
                                pnt.x = p.x + rng( -1, 1 );
                                pnt.y = p.y + rng( -1, 1 );
                                if( passable( pnt ) && !obstructed_by_vehicle_rotation( p, pnt ) ) {
                                    add_field( pnt, fd_electricity, 1, cur.get_field_age() + 1_turns );
                                    cur.set_field_intensity( cur.get_field_intensity() - 1 );
                                    tries = 0;
                                } else {
                                    tries++;
                                }
                            }
                            // We're not grounded; attempt to ground
                        } else {
                            for( const tripoint &dst : points_in_radius( p, 1 ) ) {
                                // Grounded tiles first
                                if( impassable( dst ) ) {
                                    valid.push_back( dst );
                                }
                            }
                            // Spread to adjacent space, then
                            if( valid.empty() ) {
                                tripoint dst( p + point( rng( -1, 1 ), rng( -1, 1 ) ) );
                                field_entry *elec = get_field( dst ).find_field( fd_electricity );
                                bool pass = passable( dst ) && !obstructed_by_vehicle_rotation( p, dst );
                                if( pass && elec != nullptr &&
                                    elec->get_field_intensity() < 3 ) {
                                    elec->set_field_intensity( elec->get_field_intensity() + 1 );
                                    cur.set_field_intensity( cur.get_field_intensity() - 1 );
                                } else if( pass ) {
                                    add_field( dst, fd_electricity, 1, cur.get_field_age() + 1_turns );
                                }
                                cur.set_field_intensity( cur.get_field_intensity() - 1 );
                            }
                            while( !valid.empty() && cur.get_field_intensity() > 1 ) {
                                const tripoint target = random_entry_removed( valid );
                                add_field( target, fd_electricity, 1, cur.get_field_age() + 1_turns );
                                cur.set_field_intensity( cur.get_field_intensity() - 1 );
                            }
                        }
                    }
                }
 
                int monster_spawn_chance = cur.monster_spawn_chance();
                int monster_spawn_count = cur.monster_spawn_count();
                if( monster_spawn_count > 0 && monster_spawn_chance > 0 && one_in( monster_spawn_chance ) ) {
                    for( ; monster_spawn_count > 0; monster_spawn_count-- ) {
                        MonsterGroupResult spawn_details = MonsterGroupManager::GetResultFromGroup(
                                                               cur.monster_spawn_group(), &monster_spawn_count );
                        if( !spawn_details.name ) {
                            continue;
                        }
                        if( const std::optional<tripoint> spawn_point = random_point(
                                    points_in_radius( p, cur.monster_spawn_radius() ),
                        [this]( const tripoint & n ) {
                        return passable( n );
                        } ) ) {
                            add_spawn( spawn_details.name, spawn_details.pack_size, *spawn_point );
                        }
                    }
                }
 
                if( cur_fd_type_id == fd_push_items ) {
                    map_stack items = i_at( p );
                    for( auto pushee = items.begin(); pushee != items.end(); ) {
                        if( pushee->typeId() != itype_rock ||
                            pushee->age() < 1_turns ) {
                            pushee++;
                        } else {
                            item tmp = *pushee;
                            tmp.set_age( 0_turns );
                            pushee = items.erase( pushee );
                            std::vector<tripoint> valid;
                            for( const tripoint &dst : points_in_radius( p, 1 ) ) {
                                if( get_field( dst, fd_push_items ) != nullptr ) {
                                    valid.push_back( dst );
                                }
                            }
                            if( !valid.empty() ) {
                                tripoint newp = random_entry( valid );
                                add_item_or_charges( newp, tmp );
                                if( g->u.pos() == newp ) {
                                    add_msg( m_bad, _( "A %s hits you!" ), tmp.tname() );
                                    const bodypart_id hit = g->u.get_random_body_part();
                                    g->u.deal_damage( nullptr, hit, damage_instance( DT_BASH, 6 ) );
                                    g->u.check_dead_state();
                                }
 
                                if( npc *const p = g->critter_at<npc>( newp ) ) {
                                    // TODO: combine with player character code above
                                    const bodypart_id hit = g->u.get_random_body_part();
                                    p->deal_damage( nullptr, hit, damage_instance( DT_BASH, 6 ) );
                                    if( g->u.sees( newp ) ) {
                                        add_msg( _( "A %1$s hits %2$s!" ), tmp.tname(), p->name );
                                    }
                                    p->check_dead_state();
                                } else if( monster *const mon = g->critter_at<monster>( newp ) ) {
                                    mon->apply_damage( nullptr, bodypart_id( "torso" ),
                                                       6 - mon->get_armor_bash( bodypart_id( "torso" ) ) );
                                    if( g->u.sees( newp ) ) {
                                        add_msg( _( "A %1$s hits the %2$s!" ), tmp.tname(), mon->name() );
                                    }
                                    mon->check_dead_state();
                                }
                            }
                        }
                    }
                }
                if( cur_fd_type_id == fd_shock_vent ) {
                    if( cur.get_field_intensity() > 1 ) {
                        if( one_in( 5 ) ) {
                            cur.set_field_intensity( cur.get_field_intensity() - 1 );
                        }
                    } else {
                        cur.set_field_intensity( 3 );
                        int num_bolts = rng( 3, 6 );
                        for( int i = 0; i < num_bolts; i++ ) {
                            int xdir = 0;
                            int ydir = 0;
                            while( xdir == 0 && ydir == 0 ) {
                                xdir = rng( -1, 1 );
                                ydir = rng( -1, 1 );
                            }
                            int dist = rng( 4, 12 );
                            int boltx = p.x;
                            int bolty = p.y;
                            for( int n = 0; n < dist; n++ ) {
                                boltx += xdir;
                                bolty += ydir;
                                add_field( tripoint( boltx, bolty, p.z ), fd_electricity, rng( 2, 3 ) );
                                if( one_in( 4 ) ) {
                                    if( xdir == 0 ) {
                                        xdir = rng( 0, 1 ) * 2 - 1;
                                    } else {
                                        xdir = 0;
                                    }
                                }
                                if( one_in( 4 ) ) {
                                    if( ydir == 0 ) {
                                        ydir = rng( 0, 1 ) * 2 - 1;
                                    } else {
                                        ydir = 0;
                                    }
                                }
                            }
                        }
                    }
                }
                if( cur_fd_type_id == fd_acid_vent ) {
 
                    if( cur.get_field_intensity() > 1 ) {
                        if( cur.get_field_age() >= 1_minutes ) {
                            cur.set_field_intensity( cur.get_field_intensity() - 1 );
                            cur.set_field_age( 0_turns );
                        }
                    } else {
                        cur.set_field_intensity( 3 );
                        for( const tripoint &t : points_in_radius( p, 5 ) ) {
                            const field_entry *acid = get_field( t, fd_acid );
                            if( acid != nullptr && acid->get_field_intensity() == 0 ) {
                                int new_intensity = 3 - rl_dist( p, t ) / 2 + ( one_in( 3 ) ? 1 : 0 );
                                if( new_intensity > 3 ) {
                                    new_intensity = 3;
                                }
                                if( new_intensity > 0 ) {
                                    add_field( t, fd_acid, new_intensity );
                                }
                            }
                        }
                    }
                }
                if( cur_fd_type_id == fd_bees ) {
                    // Poor bees are vulnerable to so many other fields.
                    // TODO: maybe adjust effects based on different fields.
                    if( curfield.find_field( fd_web ) ||
                        curfield.find_field( fd_fire ) ||
                        curfield.find_field( fd_smoke ) ||
                        curfield.find_field( fd_toxic_gas ) ||
                        curfield.find_field( fd_tear_gas ) ||
                        curfield.find_field( fd_relax_gas ) ||
                        curfield.find_field( fd_nuke_gas ) ||
                        curfield.find_field( fd_gas_vent ) ||
                        curfield.find_field( fd_smoke_vent ) ||
                        curfield.find_field( fd_fungicidal_gas ) ||
                        curfield.find_field( fd_insecticidal_gas ) ||
                        curfield.find_field( fd_fire_vent ) ||
                        curfield.find_field( fd_flame_burst ) ||
                        curfield.find_field( fd_electricity ) ||
                        curfield.find_field( fd_fatigue ) ||
                        curfield.find_field( fd_shock_vent ) ||
                        curfield.find_field( fd_plasma ) ||
                        curfield.find_field( fd_laser ) ||
                        curfield.find_field( fd_dazzling ) ||
                        curfield.find_field( fd_electricity ) ||
                        curfield.find_field( fd_incendiary ) ) {
                        // Kill them at the end of processing.
                        cur.set_field_intensity( 0 );
                    } else {
                        // Bees chase the player if in range, wander randomly otherwise.
                        if( !g->u.is_underwater() &&
                            rl_dist( p, g->u.pos() ) < 10 &&
                            clear_path( p, g->u.pos(), 10, 1, 100 ) ) {
 
                            std::vector<point> candidate_positions =
                                squares_in_direction( p.xy(), point( g->u.posx(), g->u.posy() ) );
                            for( point candidate_position : candidate_positions ) {
                                field &target_field = get_field( tripoint( candidate_position, p.z ) );
                                // Only shift if there are no bees already there.
                                // TODO: Figure out a way to merge bee fields without allowing
                                // Them to effectively move several times in a turn depending
                                // on iteration direction.
                                if( !target_field.find_field( fd_bees ) ) {
                                    add_field( tripoint( candidate_position, p.z ), fd_bees,
                                               cur.get_field_intensity(), cur.get_field_age() );
                                    cur.set_field_intensity( 0 );
                                    break;
                                }
                            }
                        } else {
                            spread_gas( cur, p, 5, 0_turns, sblk );
                        }
                    }
                }
                if( cur_fd_type_id == fd_incendiary ) {
                    // Needed for variable scope
                    tripoint dst( p + point( rng( -1, 1 ), rng( -1, 1 ) ) );
                    if( has_flag( TFLAG_FLAMMABLE, dst ) ||
                        has_flag( TFLAG_FLAMMABLE_ASH, dst ) ||
                        has_flag( TFLAG_FLAMMABLE_HARD, dst ) ) {
                        add_field( dst, fd_fire, 1 );
                    }
 
                    // Check piles for flammable items and set those on fire
                    if( flammable_items_at( dst ) ) {
                        add_field( dst, fd_fire, 1 );
                    }
 
                    create_hot_air( p, cur.get_field_intensity() );
                }
                if( cur_fd_type_id == fd_fungicidal_gas ) {
                    // Check the terrain and replace it accordingly to simulate the fungus dieing off
                    const ter_t &ter = map_tile.get_ter_t();
                    const furn_t &frn = map_tile.get_furn_t();
                    const int intensity = cur.get_field_intensity();
                    if( ter.has_flag( flag_FUNGUS ) && one_in( 10 / intensity ) ) {
                        ter_set( p, t_dirt );
                    }
                    if( frn.has_flag( flag_FUNGUS ) && one_in( 10 / intensity ) ) {
                        furn_set( p, f_null );
                    }
                }
 
                cur.set_field_age( cur.get_field_age() + 1_turns );
                auto &fdata = cur.get_field_type().obj();
                if( fdata.half_life > 0_turns && cur.get_field_age() > 0_turns &&
                    dice( 2, to_turns<int>( cur.get_field_age() ) ) > to_turns<int>( fdata.half_life ) ) {
                    cur.set_field_age( 0_turns );
                    cur.set_field_intensity( cur.get_field_intensity() - 1 );
                }
                if( !cur.is_field_alive() ) {
                    --current_submap->field_count;
                    curfield.remove_field( it++ );
                } else {
                    ++it;
                }
            }
 
            if( dirty_transparency_cache ) {
                set_transparency_cache_dirty( thep );
                set_seen_cache_dirty( thep );
            }
        }
    }
    const int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int z = std::max( submap.z - 1, minz ); z <= std::min( submap.z + 1, maxz ); ++z ) {
        auto &field_cache = get_cache( z ).field_cache;
        for( int y = std::max( submap.y - 1, 0 ); y <= std::min( submap.y + 1, MAPSIZE - 1 ); ++y ) {
            for( int x = std::max( submap.x - 1, 0 ); x <= std::min( submap.x + 1, MAPSIZE - 1 ); ++x ) {
                if( get_submap_at_grid( { x, y, z } )->field_count > 0 ) {
                    field_cache.set( x + y * MAPSIZE );
                } else {
                    field_cache.reset( x + y * MAPSIZE );
                }
            }
        }
    }
    sblk.commit_modifications();
}

References _, abs_sub, mattack::acid(), add_field(), add_item_or_charges(), add_msg(), add_spawn(), adjust_radiation(), scent_block::apply_slime(), field_type::apply_slime_factor, field::begin(), item_stack::begin(), check_flammable(), clear_path(), scent_block::commit_modifications(), detail::count(), create_burnproducts(), create_hot_air(), vehicle::damage(), debugmsg, destroy(), destroyed, item::detonate(), dice(), field_type::dirty_transparency_cache, field::displayed_field_type(), DT_BASH, DT_HEAT, eight_horizontal_neighbors, field::end(), item_stack::end(), map_stack::erase(), explosive, field_entry::extra_radiation_max(), field_entry::extra_radiation_min(), f_ash, f_null, fd_acid, fd_acid_vent, fd_bees, fd_dazzling, fd_electricity, fd_fatigue, fd_fire, fd_fire_vent, fd_flame_burst, fd_fungal_haze, fd_fungicidal_gas, fd_gas_vent, fd_incendiary, fd_insecticidal_gas, fd_laser, fd_nuke_gas, fd_null, fd_plasma, fd_push_items, fd_relax_gas, fd_shock_vent, fd_smoke, fd_smoke_vent, fd_tear_gas, fd_toxic_gas, fd_web, field_at(), level_cache::field_cache, submap::field_count, maptile::find_field(), field::find_field(), flag_FUNGUS(), flammable_items_at(), fire_data::fuel_produced, furn_set(), g, field_entry::gas_can_spread(), get_cache(), get_field(), submap::get_field(), field_entry::get_field_age(), field_entry::get_field_intensity(), field_entry::get_field_type(), maptile::get_furn_t(), maptile::get_item_count(), get_map(), get_neighbors(), get_submap_at_grid(), maptile::get_ter(), maptile::get_ter_t(), field_type::get_transparent(), field_entry::get_underwater_age_speedup(), MonsterGroupManager::GetResultFromGroup(), map_data_common_t::has_flag(), has_flag(), anonymous_namespace{iexamine_elevator.cpp}::elevator::here(), i_at(), int_id< T >::id(), ter_t::id, string_id< T >::id(), impassable(), field_entry::intensity_upgrade_chance(), field_entry::intensity_upgrade_duration(), field_entry::is_field_alive(), itype_rock, m_bad, MAPSIZE, maptile_at_internal(), field_entry::mod_field_age(), field_entry::monster_spawn_chance(), field_entry::monster_spawn_count(), field_entry::monster_spawn_group(), field_entry::monster_spawn_radius(), MonsterGroupResult::name, field_type::npc_complain_data, int_id< T >::obj(), obstructed_by_vehicle_rotation(), calendar::once_every(), one_in(), field_type::outdoor_age_speedup, OVERMAP_DEPTH, OVERMAP_HEIGHT, MonsterGroupResult::pack_size, passable(), field_type::percent_spread, point_zero, points_in_radius(), maptile::pos_, random_entry(), random_entry_removed(), random_point(), field::remove_field(), rl_dist(), rng(), roll_remainder(), SEEX, SEEY, item::set_age(), field_entry::set_field_age(), field_entry::set_field_intensity(), set_seen_cache_dirty(), set_transparency_cache_dirty(), spawn_items(), fungal_effects::spread_fungus(), spread_gas(), squares_in_direction(), t_dirt, t_open_air, t_pit, ter(), ter_furn_has_flag(), ter_set(), TFLAG_ALLOW_FIELD_EFFECT, TFLAG_FIRE_CONTAINER, TFLAG_FLAMMABLE, TFLAG_FLAMMABLE_ASH, TFLAG_FLAMMABLE_HARD, TFLAG_NO_FLOOR, TFLAG_SEALED, TFLAG_SWIMMABLE, item::tname(), valid_move(), veh_at_internal(), field_type::wandering_field, point::x, tripoint::x, tripoint::xy(), point::y, tripoint::y, tripoint::z, and zlevels.

Referenced by process_fields().

◆ process_items()

void map::process_items ( )

Definition at line 4700 of file map.cpp.

{
    const int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int gz = minz; gz <= maxz; ++gz ) {
        level_cache &cache = access_cache( gz );
        std::set<tripoint> submaps_with_vehicles;
        for( vehicle *this_vehicle : cache.vehicle_list ) {
            tripoint pos = this_vehicle->global_pos3();
            submaps_with_vehicles.emplace( pos.x / SEEX, pos.y / SEEY, pos.z );
        }
        for( const tripoint &pos : submaps_with_vehicles ) {
            submap *const current_submap = get_submap_at_grid( pos );
            // Vehicles first in case they get blown up and drop active items on the map.
            process_items_in_vehicles( *current_submap );
        }
    }
    // Making a copy, in case the original variable gets modified during `process_items_in_submap`
    const std::set<tripoint> submaps_with_active_items_copy = submaps_with_active_items;
    for( const tripoint &abs_pos : submaps_with_active_items_copy ) {
        const tripoint local_pos = abs_pos - abs_sub.xy();
        submap *const current_submap = get_submap_at_grid( local_pos );
        if( !current_submap->active_items.empty() ) {
            process_items_in_submap( *current_submap, local_pos );
        }
    }
}

References abs_sub, access_cache(), submap::active_items, active_item_cache::empty(), get_submap_at_grid(), vehicle::global_pos3(), OVERMAP_DEPTH, OVERMAP_HEIGHT, wrapped_vehicle::pos, process_items_in_submap(), process_items_in_vehicles(), SEEX, SEEY, submaps_with_active_items, level_cache::vehicle_list, tripoint::x, tripoint::xy(), tripoint::y, tripoint::z, and zlevels.

Referenced by game::do_turn().

◆ process_items_in_submap()

void map::process_items_in_submap	(	submap &	current_submap,
		const tripoint &	gridp
	)

private

Definition at line 4743 of file map.cpp.

{
    // Get a COPY of the active item list for this submap.
    // If more are added as a side effect of processing, they are ignored this turn.
    // If they are destroyed before processing, they don't get processed.
    std::vector<item_reference> active_items = current_submap.active_items.get_for_processing();
    const point grid_offset( gridp.x * SEEX, gridp.y * SEEY );
    for( item_reference &active_item_ref : active_items ) {
        if( !active_item_ref.item_ref ) {
            // The item was destroyed, so skip it.
            continue;
        }
 
        const tripoint map_location = tripoint( grid_offset + active_item_ref.location, gridp.z );
        temperature_flag flag = temperature_flag_at_point( *this, map_location );
        map_stack items = i_at( map_location );
        process_map_items( items, active_item_ref.item_ref, map_location, flag );
    }
}

References submap::active_items, active_item_cache::get_for_processing(), i_at(), process_map_items(), SEEX, SEEY, temperature_flag_at_point(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by process_items().

◆ process_items_in_vehicle()

void map::process_items_in_vehicle	(	vehicle &	cur_veh,
		submap &	current_submap
	)

private

Definition at line 4784 of file map.cpp.

{
    const bool engine_heater_is_on = cur_veh.has_part( "E_HEATER", true ) && cur_veh.engine_on;
    for( const vpart_reference &vp : cur_veh.get_any_parts( VPFLAG_FLUIDTANK ) ) {
        vp.part().process_contents( vp.pos(), engine_heater_is_on );
    }
 
    auto cargo_parts = cur_veh.get_parts_including_carried( VPFLAG_CARGO );
    for( const vpart_reference &vp : cargo_parts ) {
        process_vehicle_items( cur_veh, vp.part_index() );
    }
 
    for( item_reference &active_item_ref : cur_veh.active_items.get_for_processing() ) {
        if( empty( cargo_parts ) ) {
            return;
        } else if( !active_item_ref.item_ref ) {
            // The item was destroyed, so skip it.
            continue;
        }
        const auto it = std::find_if( begin( cargo_parts ),
        end( cargo_parts ), [&]( const vpart_reference & part ) {
            return active_item_ref.location == part.mount();
        } );
 
        if( it == end( cargo_parts ) ) {
            continue; // Can't find a cargo part matching the active item.
        }
        const item &target = *active_item_ref.item_ref;
        // Find the cargo part and coordinates corresponding to the current active item.
        const vehicle_part &pt = it->part();
        const tripoint item_loc = it->pos();
        auto items = cur_veh.get_items( static_cast<int>( it->part_index() ) );
        temperature_flag flag = temperature_flag::TEMP_NORMAL;
        if( target.is_food() || target.is_food_container() || target.is_corpse() ) {
            const vpart_info &pti = pt.info();
            if( engine_heater_is_on ) {
                flag = temperature_flag::TEMP_HEATER;
            }
 
            if( pt.enabled && pti.has_flag( VPFLAG_FRIDGE ) ) {
                flag = temperature_flag::TEMP_FRIDGE;
            } else if( pt.enabled && pti.has_flag( VPFLAG_FREEZER ) ) {
                flag = temperature_flag::TEMP_FREEZER;
            }
        }
        if( !process_map_items( items, active_item_ref.item_ref, item_loc, flag ) ) {
            // If the item was NOT destroyed, we can skip the remainder,
            // which handles fallout from the vehicle being damaged.
            continue;
        }
 
        // item does not exist anymore, might have been an exploding bomb,
        // check if the vehicle is still valid (does exist)
        if( !current_submap.contains_vehicle( &cur_veh ) ) {
            // Nope, vehicle is not in the vehicle list of the submap,
            // it might have moved to another submap (unlikely)
            // or be destroyed, anyway it does not need to be processed here
            return;
        }
 
        // Vehicle still valid, reload the list of cargo parts,
        // the list of cargo parts might have changed (imagine a part with
        // a low index has been removed by an explosion, all the other
        // parts would move up to fill the gap).
        cargo_parts = cur_veh.get_any_parts( VPFLAG_CARGO );
    }
}

References vehicle::active_items, submap::contains_vehicle(), vehicle_part::enabled, vehicle::engine_on, vehicle::get_any_parts(), active_item_cache::get_for_processing(), vehicle::get_items(), vehicle::get_parts_including_carried(), vpart_info::has_flag(), vehicle::has_part(), vehicle_part::info(), item::is_corpse(), item::is_food(), item::is_food_container(), vpart_position::mount(), process_map_items(), process_vehicle_items(), TEMP_FREEZER, TEMP_FRIDGE, TEMP_HEATER, TEMP_NORMAL, VPFLAG_CARGO, VPFLAG_FLUIDTANK, VPFLAG_FREEZER, and VPFLAG_FRIDGE.

Referenced by process_items_in_vehicles().

◆ process_items_in_vehicles()

void map::process_items_in_vehicles ( submap & current_submap )

private

Definition at line 4763 of file map.cpp.

{
    // a copy, important if the vehicle list changes because a
    // vehicle got destroyed by a bomb (an active item!), this list
    // won't change, but veh_in_nonant will change.
    std::vector<vehicle *> vehicles;
    for( const auto &veh : current_submap.vehicles ) {
        vehicles.push_back( veh.get() );
    }
    for( auto &cur_veh : vehicles ) {
        if( !current_submap.contains_vehicle( cur_veh ) ) {
            // vehicle not in the vehicle list of the nonant, has been
            // destroyed (or moved to another nonant?)
            // Can't be sure that it still exists, so skip it
            continue;
        }
 
        process_items_in_vehicle( *cur_veh, current_submap );
    }
}

References submap::contains_vehicle(), process_items_in_vehicle(), and submap::vehicles.

Referenced by process_items().

◆ produce_sap()

void map::produce_sap	(	const tripoint &	p,
		const time_duration &	time_since_last_actualize
	)

protected

Produce sap on tapped maple trees.

Parameters

p	Location of tapped tree
time_since_last_actualize	Time since this function has been called the last time.

Definition at line 7384 of file map.cpp.

{
    if( time_since_last_actualize <= 0_turns ) {
        return;
    }
 
    if( t_tree_maple_tapped != ter( p ) ) {
        return;
    }
 
    // Amount of maple sap liters produced per season per tap
    static const int maple_sap_per_season = 56;
 
    // How many turns to produce 1 charge (250 ml) of sap?
    const time_duration producing_length = 0.75 * calendar::season_length();
 
    const time_duration turns_to_produce = producing_length / ( maple_sap_per_season * 4 );
 
    // How long of this time_since_last_actualize have we been in the producing period (late winter, early spring)?
    time_duration time_producing = 0_turns;
 
    if( time_since_last_actualize >= calendar::year_length() ) {
        time_producing = producing_length;
    } else {
        // We are only producing sap on the intersection with the sap producing season.
        const time_duration early_spring_end = 0.5f * calendar::season_length();
        const time_duration late_winter_start = 3.75f * calendar::season_length();
 
        const time_point last_actualize = calendar::turn - time_since_last_actualize;
        const time_duration last_actualize_tof = time_past_new_year( last_actualize );
        bool last_producing = (
                                  last_actualize_tof >= late_winter_start ||
                                  last_actualize_tof < early_spring_end
                              );
        const time_duration current_tof = time_past_new_year( calendar::turn );
        bool current_producing = (
                                     current_tof >= late_winter_start ||
                                     current_tof < early_spring_end
                                 );
 
        const time_duration non_producing_length = 3.25 * calendar::season_length();
 
        if( last_producing && current_producing ) {
            if( time_since_last_actualize < non_producing_length ) {
                time_producing = time_since_last_actualize;
            } else {
                time_producing = time_since_last_actualize - non_producing_length;
            }
        } else if( !last_producing && !current_producing ) {
            if( time_since_last_actualize > non_producing_length ) {
                time_producing = time_since_last_actualize - non_producing_length;
            }
        } else if( last_producing && !current_producing ) {
            // We hit the end of early spring
            if( last_actualize_tof < early_spring_end ) {
                time_producing = early_spring_end - last_actualize_tof;
            } else {
                time_producing = calendar::year_length() - last_actualize_tof + early_spring_end;
            }
        } else if( !last_producing && current_producing ) {
            // We hit the start of late winter
            if( current_tof >= late_winter_start ) {
                time_producing = current_tof - late_winter_start;
            } else {
                time_producing = 0.25f * calendar::season_length() + current_tof;
            }
        }
    }
 
    int new_charges = roll_remainder( time_producing / turns_to_produce );
    // Not enough time to produce 1 charge of sap
    if( new_charges <= 0 ) {
        return;
    }
 
    item sap( "maple_sap", calendar::turn );
 
    // Is there a proper container?
    auto items = i_at( p );
    for( auto &it : items ) {
        if( it.is_bucket() || it.is_watertight_container() ) {
            const int capacity = it.get_remaining_capacity_for_liquid( sap, true );
            if( capacity > 0 ) {
                new_charges = std::min( new_charges, capacity );
 
                // The environment might have poisoned the sap with animals passing by, insects, leaves or contaminants in the ground
                sap.poison = one_in( 10 ) ? 1 : 0;
                sap.charges = new_charges;
 
                it.fill_with( sap );
            }
            // Only fill up the first container.
            break;
        }
    }
}

References item::charges, i_at(), one_in(), item::poison, roll_remainder(), calendar::season_length(), t_tree_maple_tapped, ter(), time_past_new_year(), calendar::turn, and calendar::year_length().

Referenced by actualize().

◆ propagate_field()

void map::propagate_field	(	const tripoint &	center,
		const field_type_id &	type,
		int	amount,
		int	max_intensity = `0`
	)

Definition at line 1941 of file map_field.cpp.

{
    using gas_blast = std::pair<float, tripoint>;
    std::priority_queue<gas_blast, std::vector<gas_blast>, pair_greater_cmp_first> open;
    std::set<tripoint> closed;
    open.push( { 0.0f, center } );
 
    const bool not_gas = type.obj().phase != GAS;
 
    while( amount > 0 && !open.empty() ) {
        if( closed.count( open.top().second ) ) {
            open.pop();
            continue;
        }
 
        // All points with equal gas intensity should propagate at the same time
        std::list<gas_blast> gas_front;
        gas_front.push_back( open.top() );
        const int cur_intensity = get_field_intensity( open.top().second, type );
        open.pop();
        while( !open.empty() && get_field_intensity( open.top().second, type ) == cur_intensity ) {
            if( closed.count( open.top().second ) == 0 ) {
                gas_front.push_back( open.top() );
            }
 
            open.pop();
        }
 
        int increment = std::max<int>( 1, amount / gas_front.size() );
 
        while( !gas_front.empty() ) {
            gas_blast gp = random_entry_removed( gas_front );
            closed.insert( gp.second );
            const int cur_intensity = get_field_intensity( gp.second, type );
            if( cur_intensity < max_intensity ) {
                const int bonus = std::min( max_intensity - cur_intensity, increment );
                mod_field_intensity( gp.second, type, bonus );
                amount -= bonus;
            } else {
                amount--;
            }
 
            if( amount <= 0 ) {
                return;
            }
 
            static const std::array<int, 8> x_offset = {{ -1, 1,  0, 0,  1, -1, -1, 1  }};
            static const std::array<int, 8> y_offset = {{  0, 0, -1, 1, -1,  1, -1, 1  }};
            for( size_t i = 0; i < 8; i++ ) {
                tripoint pt = gp.second + point( x_offset[ i ], y_offset[ i ] );
                if( closed.count( pt ) > 0 ) {
                    continue;
                }
 
                if( impassable( pt ) && ( not_gas || !has_flag( TFLAG_PERMEABLE, pt ) ) ) {
                    closed.insert( pt );
                    continue;
                }
                if( !obstructed_by_vehicle_rotation( gp.second, pt ) ) {
                    open.push( { static_cast<float>( rl_dist( center, pt ) ), pt } );
                }
            }
        }
    }
}

References center, GAS, get_field_intensity(), has_flag(), impassable(), mod_field_intensity(), obstructed_by_vehicle_rotation(), open(), random_entry_removed(), rl_dist(), TFLAG_PERMEABLE, and type.

Referenced by emit_field().

◆ propagate_suspension_check()

void map::propagate_suspension_check ( const tripoint & point )

Checks surrounding tiles for suspension, and has them check for collapse.

!!Should only be called after the tile at this point has been destroyed!!

Definition at line 3006 of file map.cpp.

{
    for( const tripoint &neighbor : points_in_radius( point, 1 ) ) {
        if( neighbor != point && has_flag( TFLAG_SUSPENDED, neighbor ) ) {
            collapse_invalid_suspension( neighbor );
        }
    }
}

References collapse_invalid_suspension(), has_flag(), points_in_radius(), and TFLAG_SUSPENDED.

Referenced by bash_ter_success(), collapse_at(), and collapse_invalid_suspension().

◆ put_items_from_loc()

std::vector< item * > map::put_items_from_loc	(	const item_group_id &	loc,
		const tripoint &	p,
		const time_point &	turn = `calendar::start_of_cataclysm`
	)

Place items from an item group at p.

Places as much items as the item group says. (Most item groups are distributions and will only create one item.)

Parameters

loc	Current location of items
p	Destination of items
turn	The birthday that the created items shall have.

Returns: Vector of pointers to placed items (can be empty, but no nulls).

Definition at line 5409 of file mapgen.cpp.

{
    const auto items = item_group::items_from( loc, turn );
    return spawn_items( p, items );
}

References item_group::items_from(), spawn_items(), and calendar::turn.

Referenced by add_corpse(), mapgen_cavern(), MapExtras::mx_corpses(), MapExtras::mx_grave(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), and place_items().

◆ rad_scorch()

void map::rad_scorch	(	const tripoint &	p,
		const time_duration &	time_since_last_actualize
	)

protected

Radiation-related plant (and fungus?) death.

Definition at line 7481 of file map.cpp.

{
    const int rads = get_radiation( p );
    if( rads == 0 ) {
        return;
    }
 
    // TODO: More interesting rad scorch chance - base on season length?
    if( !x_in_y( 1.0 * rads * rads * time_since_last_actualize, 91_days ) ) {
        return;
    }
 
    // First destroy the farmable plants (those are furniture)
    // TODO: Rad-resistant mutant plants (that produce radioactive fruit)
    const furn_t &fid = furn( p ).obj();
    if( fid.has_flag( "PLANT" ) ) {
        i_clear( p );
        furn_set( p, f_null );
    }
 
    const ter_id tid = ter( p );
    // TODO: De-hardcode this
    static const std::map<ter_id, ter_str_id> dies_into {{
            {t_grass, ter_str_id( "t_dirt" )},
            {t_tree_young, ter_str_id( "t_dirt" )},
            {t_tree_pine, ter_str_id( "t_tree_deadpine" )},
            {t_tree_birch, ter_str_id( "t_tree_birch_harvested" )},
            {t_tree_willow, ter_str_id( "t_tree_willow_harvested" )},
            {t_tree_hickory, ter_str_id( "t_tree_hickory_dead" )},
            {t_tree_hickory_harvested, ter_str_id( "t_tree_hickory_dead" )},
        }};
 
    const auto iter = dies_into.find( tid );
    if( iter != dies_into.end() ) {
        ter_set( p, iter->second );
        return;
    }
 
    const ter_t &tr = tid.obj();
    if( tr.has_flag( "SHRUB" ) ) {
        ter_set( p, t_dirt );
    } else if( tr.has_flag( "TREE" ) ) {
        ter_set( p, ter_str_id( "t_tree_dead" ) );
    }
}

References f_null, furn(), furn_set(), get_radiation(), map_data_common_t::has_flag(), i_clear(), int_id< T >::obj(), t_dirt, t_grass, t_tree_birch, t_tree_hickory, t_tree_hickory_harvested, t_tree_pine, t_tree_willow, t_tree_young, ter(), ter_set(), and x_in_y().

Referenced by actualize().

◆ random_outdoor_tile()

point map::random_outdoor_tile ( )

Definition at line 2793 of file map.cpp.

{
    std::vector<point> options;
    for( const tripoint &p : points_on_zlevel() ) {
        if( is_outside( p.xy() ) ) {
            options.push_back( p.xy() );
        }
    }
    return random_entry( options, point_north_west );
}

References is_outside(), PATH_INFO::options(), point_north_west, points_on_zlevel(), and random_entry().

◆ ranged_target_size()

double map::ranged_target_size ( const tripoint & p ) const

Size of map objects at p for purposes of ranged combat.

Size is in percentage of tile: if 1.0, all attacks going through tile should hit map objects on it, if 0.0 there is nothing to be hit (air/water).

Definition at line 2020 of file map.cpp.

{
    if( impassable( p ) ) {
        return 1.0;
    }
 
    if( !has_floor( p ) ) {
        return 0.0;
    }
 
    // TODO: Handle cases like shrubs, trees, furniture, sandbags...
    return 0.1;
}

References has_floor(), and impassable().

◆ reachable_flood_steps()

void map::reachable_flood_steps	(	std::vector< tripoint > &	reachable_pts,
		const tripoint &	f,
		int	range,
		int	cost_min,
		int	cost_max
	)		const

Populates a vector of points that are reachable within a number of steps from a point.

It could be generalized to take advantage of z levels, but would need some additional code to detect whether a valid transition was on a tile.

Does the following:

Checks if a point is reachable using a flood fill and if it is, adds it to a vector.

Definition at line 6425 of file map.cpp.

{
    struct pq_item {
        int dist;
        int ndx;
    };
    struct pq_item_comp {
        bool operator()( const pq_item &left, const pq_item &right ) {
            return left.dist > right.dist;
        }
    };
    using PQ_type = std::priority_queue< pq_item, std::vector<pq_item>, pq_item_comp>;
 
    // temp buffer for grid
    const int grid_dim = range * 2 + 1;
    // init to -1 as "not visited yet"
    std::vector< int > t_grid( static_cast<size_t>( grid_dim * grid_dim ), -1 );
    const tripoint origin_offset = {range, range, 0};
    const int initial_visit_distance = range * range; // Large unreachable value
 
    // Fill positions that are visitable with initial_visit_distance
    for( const tripoint &p : points_in_radius( f, range ) ) {
        const tripoint tp = { p.xy(), f.z };
        const int tp_cost = move_cost( tp );
        // rejection conditions
        if( tp_cost < cost_min || tp_cost > cost_max || !has_floor_or_support( tp ) ) {
            continue;
        }
        // set initial cost for grid point
        tripoint origin_relative = tp - f;
        origin_relative += origin_offset;
        int ndx = origin_relative.x + origin_relative.y * grid_dim;
        t_grid[ ndx ] = initial_visit_distance;
    }
 
    auto gen_neighbors = []( const pq_item & elem, int grid_dim, pq_item * neighbors ) {
        // Up to 8 neighbors
        int new_cost = elem.dist + 1;
        // *INDENT-OFF*
        int ox[8] = {
            -1, 0, 1,
            -1,    1,
            -1, 0, 1
        };
        int oy[8] = {
            -1, -1, -1,
            0,      0,
            1,  1,  1
        };
        // *INDENT-ON*
 
        point e( elem.ndx % grid_dim, elem.ndx / grid_dim );
        for( int i = 0; i < 8; ++i ) {
            point n( e + point( ox[i], oy[i] ) );
 
            int ndx = n.x + n.y * grid_dim;
            neighbors[i] = { new_cost, ndx };
        }
    };
 
    PQ_type pq( pq_item_comp{} );
    pq_item first_item{ 0, range + range * grid_dim };
    pq.push( first_item );
    pq_item neighbor_elems[8];
 
    while( !pq.empty() ) {
        const pq_item item = pq.top();
        pq.pop();
 
        if( t_grid[ item.ndx ] == initial_visit_distance ) {
            t_grid[ item.ndx ] = item.dist;
            if( item.dist + 1 < range ) {
                gen_neighbors( item, grid_dim, neighbor_elems );
                for( pq_item neighbor_elem : neighbor_elems ) {
                    pq.push( neighbor_elem );
                }
            }
        }
    }
    std::vector<char> o_grid( static_cast<size_t>( grid_dim * grid_dim ), 0 );
    for( int y = 0, ndx = 0; y < grid_dim; ++y ) {
        for( int x = 0; x < grid_dim; ++x, ++ndx ) {
            if( t_grid[ ndx ] != -1 && t_grid[ ndx ] < initial_visit_distance ) {
                // set self and neighbors to 1
                for( int dy = -1; dy <= 1; ++dy ) {
                    for( int dx = -1; dx <= 1; ++dx ) {
                        int tx = dx + x;
                        int ty = dy + y;
 
                        if( tx >= 0 && tx < grid_dim && ty >= 0 && ty < grid_dim ) {
                            o_grid[ tx + ty * grid_dim ] = 1;
                        }
                    }
                }
            }
        }
    }
 
    // Now go over again to pull out all of the reachable points
    for( int y = 0, ndx = 0; y < grid_dim; ++y ) {
        for( int x = 0; x < grid_dim; ++x, ++ndx ) {
            if( o_grid[ ndx ] ) {
                tripoint t = f - origin_offset + tripoint{ x, y, 0 };
                reachable_pts.push_back( t );
            }
        }
    }
}

References has_floor_or_support(), left, move_cost(), points_in_radius(), range, right, point::x, tripoint::x, tripoint::xy(), point::y, tripoint::y, and tripoint::z.

Referenced by inventory::form_from_map(), and use_charges().

◆ register_vehicle_zone()

void map::register_vehicle_zone	(	vehicle *	veh,
		int	zlev
	)

Definition at line 1017 of file map.cpp.

{
    auto &ch = get_cache( zlev );
    ch.zone_vehicles.insert( veh );
}

References get_cache().

Referenced by zone_manager::create_vehicle_loot_zone().

◆ remove_field()

void map::remove_field	(	const tripoint &	p,
		const field_type_id &	field_to_remove
	)

Remove field entry at xy, ignored if the field entry is not present.

Definition at line 5593 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    if( current_submap->get_field( l ).remove_field( field_to_remove ) ) {
        // Only adjust the count if the field actually existed.
        if( !--current_submap->field_count ) {
            get_cache( p.z ).field_cache.set( static_cast<size_t>( p.x / SEEX + ( (
                                                  p.y / SEEX ) * MAPSIZE ) ) );
        }
        const auto &fdata = field_to_remove.obj();
        if( fdata.dirty_transparency_cache || !fdata.is_transparent() ) {
            set_transparency_cache_dirty( p );
            set_seen_cache_dirty( p );
        }
        if( fdata.is_dangerous() ) {
            set_pathfinding_cache_dirty( p.z );
        }
    }
}

References level_cache::field_cache, submap::field_count, get_cache(), submap::get_field(), get_submap_at(), inbounds(), MAPSIZE, int_id< T >::obj(), field::remove_field(), SEEX, set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_transparency_cache_dirty(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by bash_field(), game::grabbed_furn_move(), MapExtras::mx_house_spider(), MapExtras::mx_spider(), game::process_artifact(), set_field_intensity(), shoot(), and game::walk_move().

◆ remove_rotten_items()

template<typename Container >

void map::remove_rotten_items	(	Container &	items,
		const tripoint &	p,
		temperature_flag	temperature
	)

protected

Go through the list of items, update their rotten status and remove items that have rotten away completely.

Parameters

items	items to remove
p	The point on this map where the items are, used for rot calculation.
temperature	flag that overrides temperature processing at certain locations

Definition at line 7230 of file map.cpp.

{
    for( auto it = items.begin(); it != items.end(); ) {
        if( it->actualize_rot( pnt, temperature, get_weather() ) ) {
            if( it->is_comestible() ) {
                rotten_item_spawn( *it, pnt );
            }
            it = i_rem( pnt, it );
        } else {
            ++it;
        }
    }
}

References get_weather(), i_rem(), and rotten_item_spawn().

Referenced by actualize().

◆ remove_submap_camp()

void map::remove_submap_camp ( const tripoint & p )

Definition at line 5708 of file map.cpp.

{
    get_submap_at( p )->camp.reset();
}

References submap::camp, and get_submap_at().

Referenced by game::validate_camps().

◆ remove_trap()

void map::remove_trap ( const tripoint & p )

Definition at line 5394 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    trap_id tid = current_submap->get_trap( l );
    if( tid != tr_null ) {
        if( g != nullptr && this == &get_map() ) {
            g->u.add_known_trap( p, tr_null.obj() );
        }
 
        current_submap->set_trap( l, tr_null );
        auto &traps = traplocs[tid.to_i()];
        const auto iter = std::find( traps.begin(), traps.end(), p );
        if( iter != traps.end() ) {
            traps.erase( iter );
        }
    }
}

References detail::find(), g, get_map(), get_submap_at(), submap::get_trap(), inbounds(), int_id< T >::obj(), submap::set_trap(), int_id< T >::to_i(), tr_null, and traplocs.

Referenced by mremove_trap(), trap::on_disarmed(), game::process_artifact(), and trap_set().

◆ reset_vehicle_cache()

void map::reset_vehicle_cache ( )

Definition at line 314 of file map.cpp.

{
    last_full_vehicle_list_dirty = true;
    clear_vehicle_cache();
 
    // Cache all vehicles
    const int zmin = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int zmax = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int zlev = zmin; zlev <= zmax; zlev++ ) {
        auto &ch = get_cache( zlev );
        for( const auto &elem : ch.vehicle_list ) {
            elem->adjust_zlevel( 0, tripoint_zero );
            add_vehicle_to_cache( elem );
        }
    }
}

References abs_sub, add_vehicle_to_cache(), clear_vehicle_cache(), get_cache(), last_full_vehicle_list_dirty, OVERMAP_DEPTH, OVERMAP_HEIGHT, tripoint_zero, tripoint::z, and zlevels.

Referenced by detach_vehicle(), editmap::draw_main_ui_overlay(), load(), loadn(), rotate(), shift(), and vehicle::use_bike_rack().

◆ restock_fruits()

void map::restock_fruits	(	const tripoint &	p,
		const time_duration &	time_since_last_actualize
	)

protected

Try to grow fruits on static plants (not planted by the player)

Parameters

p	Place to restock
time_since_last_actualize	Time since this function has been called the last time.

Definition at line 7370 of file map.cpp.

{
    const auto &ter = this->ter( p ).obj();
    if( !ter.has_flag( TFLAG_HARVESTED ) ) {
        return; // Already harvestable. Do nothing.
    }
    // Make it harvestable again if the last actualization was during a different season or year.
    const time_point last_touched = calendar::turn - time_since_last_actualize;
    if( season_of_year( calendar::turn ) != season_of_year( last_touched ) ||
        time_since_last_actualize >= calendar::season_length() ) {
        ter_set( p, ter.transforms_into );
    }
}

References int_id< T >::obj(), calendar::season_length(), season_of_year(), ter(), ter_set(), TFLAG_HARVESTED, and calendar::turn.

Referenced by actualize(), and saven().

◆ restore_vision_transparency_cache()

void map::restore_vision_transparency_cache	(	const tripoint &	center,
		int	target_z,
		float(&)	vision_restore_cache[9],
		bool(&)	blocked_restore_cache[8]
	)

protected

Definition at line 1506 of file lightmap.cpp.

{
    auto &map_cache = get_cache( target_z );
    float ( &transparency_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.transparency_cache;
    diagonal_blocks( &blocked_cache )[MAPSIZE_X][MAPSIZE_Y] = map_cache.vehicle_obscured_cache;
 
    int i = 0;
    for( point adjacent : eight_adjacent_offsets ) {
        const tripoint p = center + adjacent;
        if( !inbounds( p ) ) {
            continue;
        }
        transparency_cache[p.x][p.y] = vision_restore_cache[i];
 
        if( blocked_restore_cache[i] ) {
            bool &relevant_blocked = adjacent == point_north_east ? blocked_cache[center.x][center.y].ne :
                                     adjacent == point_south_east ? blocked_cache[p.x][p.y].nw :
                                     adjacent == point_south_west ? blocked_cache[p.x][p.y].ne :
                                     /* point_north_west */ blocked_cache[center.x][center.y].nw;
            relevant_blocked = false;
        }
 
        i++;
    }
    transparency_cache[center.x][center.y] = vision_restore_cache[8];
}

References center, eight_adjacent_offsets, get_cache(), inbounds(), MAPSIZE_X, MAPSIZE_Y, point_north_east, point_south_east, point_south_west, tripoint::x, and tripoint::y.

Referenced by build_seen_cache().

◆ rotate()

void map::rotate	(	int	turns,
		bool	setpos_safe = `false`
	)

Rotates this map, and all of its contents, by the specified multiple of 90 degrees.

Parameters

turns How many 90-degree turns to rotate the map.

Definition at line 5636 of file mapgen.cpp.

{
 
    //Handle anything outside the 1-3 range gracefully; rotate(0) is a no-op.
    turns = turns % 4;
    if( turns == 0 ) {
        return;
    }
 
    real_coords rc;
    const tripoint &abs_sub = get_abs_sub();
    rc.fromabs( point( abs_sub.x * SEEX, abs_sub.y * SEEY ) );
 
    // TODO: This radius can be smaller - how small?
    const int radius = HALF_MAPSIZE + 3;
    // uses submap coordinates
    // TODO: fix point types
    const std::vector<shared_ptr_fast<npc>> npcs =
            overmap_buffer.get_npcs_near( tripoint_abs_sm( abs_sub ), radius );
    for( const shared_ptr_fast<npc> &i : npcs ) {
        npc &np = *i;
        const tripoint sq = np.global_square_location();
        const point local_sq = getlocal( sq ).xy();
 
        real_coords np_rc;
        np_rc.fromabs( sq.xy() );
        // Note: We are rotating the entire overmap square (2x2 of submaps)
        if( np_rc.om_pos != rc.om_pos || sq.z != abs_sub.z ) {
            continue;
        }
 
        // OK, this is ugly: we remove the NPC from the whole map
        // Then we place it back from scratch
        // It could be rewritten to utilize the fact that rotation shouldn't cross overmaps
 
        point old( np_rc.sub_pos );
        if( np_rc.om_sub.x % 2 != 0 ) {
            old.x += SEEX;
        }
        if( np_rc.om_sub.y % 2 != 0 ) {
            old.y += SEEY;
        }
 
        const point new_pos = old .rotate( turns, { SEEX * 2, SEEY * 2 } );
        if( setpos_safe ) {
            // setpos can't be used during mapgen, but spawn_at_precise clips position
            // to be between 0-11,0-11 and teleports NPCs when used inside of update_mapgen
            // calls
            const tripoint new_global_sq = sq - local_sq + new_pos;
            np.setpos( get_map().getlocal( new_global_sq ) );
        } else {
            // OK, this is ugly: we remove the NPC from the whole map
            // Then we place it back from scratch
            // It could be rewritten to utilize the fact that rotation shouldn't cross overmaps
            shared_ptr_fast<npc> npc_ptr = overmap_buffer.remove_npc( np.getID() );
            np.spawn_at_precise( { abs_sub.xy() }, { new_pos, abs_sub.z } );
            overmap_buffer.insert_npc( npc_ptr );
        }
    }
 
    clear_vehicle_cache( );
    clear_vehicle_list( abs_sub.z );
 
    // Move the submaps around.
    if( turns == 2 ) {
        std::swap( *get_submap_at_grid( point_zero ), *get_submap_at_grid( point_south_east ) );
        std::swap( *get_submap_at_grid( point_east ), *get_submap_at_grid( point_south ) );
    } else {
        point p;
        submap tmp;
 
        std::swap( *get_submap_at_grid( point_south_east - p ), tmp );
 
        for( int k = 0; k < 4; ++k ) {
            p = p.rotate( turns, { 2, 2 } );
            std::swap( *get_submap_at_grid( point_south_east - p ), tmp );
        }
    }
 
    // Then rotate them and recalculate vehicle positions.
    for( int j = 0; j < 2; ++j ) {
        for( int i = 0; i < 2; ++i ) {
            point p( i, j );
            auto sm = get_submap_at_grid( p );
 
            sm->rotate( turns );
 
            for( auto &veh : sm->vehicles ) {
                veh->sm_pos = tripoint( p, abs_sub.z );
            }
 
            update_vehicle_list( sm, abs_sub.z );
        }
    }
    reset_vehicle_cache( );
 
    // rotate zones
    zone_manager &mgr = zone_manager::get_manager();
    mgr.rotate_zones( *this, turns );
}

References abs_sub, clear_vehicle_cache(), clear_vehicle_list(), real_coords::fromabs(), get_abs_sub(), zone_manager::get_manager(), get_map(), overmapbuffer::get_npcs_near(), get_submap_at_grid(), Character::getID(), getlocal(), npc::global_square_location(), HALF_MAPSIZE, overmapbuffer::insert_npc(), real_coords::om_pos, real_coords::om_sub, overmap_buffer, point_east, point_south, point_south_east, point_zero, overmapbuffer::remove_npc(), reset_vehicle_cache(), point::rotate(), zone_manager::rotate_zones(), SEEX, SEEY, npc::setpos(), coords::sm, npc::spawn_at_precise(), real_coords::sub_pos, cata::swap(), update_vehicle_list(), point::x, tripoint::x, tripoint::xy(), point::y, tripoint::y, and tripoint::z.

Referenced by draw_connections(), draw_lab(), draw_office_tower(), draw_triffid(), mapgen_function_json::generate(), mapgen_ants_curved(), mapgen_ants_straight(), mapgen_ants_tee(), mapgen_forest_trail_curved(), mapgen_forest_trail_straight(), mapgen_forest_trail_tee(), mapgen_highway(), mapgen_parking_lot(), editmap::mapgen_preview(), mapgen_railroad(), mapgen_railroad_bridge(), mapgen_river_curved(), mapgen_river_curved_not(), mapgen_river_straight(), mapgen_road(), mapgen_rotate(), mapgen_sewer_curved(), mapgen_sewer_straight(), mapgen_sewer_tee(), mapgen_subway(), and update_mapgen_function_json::update_map().

◆ rotten_item_spawn()

void map::rotten_item_spawn	(	const item &	item,
		const tripoint &	p
	)

Checks to see if the item that is rotting away generates a creature when it does.

Parameters

item	item that is spawning creatures
p	The point on this map where the item is and creature will be

Definition at line 7244 of file map.cpp.

{
    if( g->critter_at( pnt ) != nullptr ) {
        return;
    }
    const auto &comest = item.get_comestible();
    mongroup_id mgroup = comest->rot_spawn;
    if( !mgroup ) {
        return;
    }
    const int chance = static_cast<int>( comest->rot_spawn_chance *
                                         get_option<float>( "CARRION_SPAWNRATE" ) );
    if( rng( 0, 100 ) < chance ) {
        MonsterGroupResult spawn_details = MonsterGroupManager::GetResultFromGroup( mgroup );
        add_spawn( spawn_details.name, 1, pnt, false );
        if( g->u.sees( pnt ) ) {
            if( item.is_seed() ) {
                add_msg( m_warning, _( "Something has crawled out of the %s plants!" ), item.get_plant_name() );
            } else {
                add_msg( m_warning, _( "Something has crawled out of the %s!" ), item.tname() );
            }
        }
    }
}

References _, add_msg(), add_spawn(), g, item::get_comestible(), item::get_plant_name(), MonsterGroupManager::GetResultFromGroup(), item::is_seed(), m_warning, MonsterGroupResult::name, rng(), and item::tname().

Referenced by grow_plant(), and remove_rotten_items().

◆ route()

std::vector< tripoint > map::route	(	const tripoint &	f,
		const tripoint &	t,
		const pathfinding_settings &	settings,
		const std::set< tripoint > &	pre_closed = `{{ }}`
	)		const

Calculate the best path using A*.

Parameters

f	The source location from which to path.
t	The destination to which to path.
settings	Structure describing pathfinding parameters.
pre_closed	Never path through those points. They can still be the source or the destination.

Definition at line 195 of file pathfinding.cpp.

{
    /* TODO: If the origin or destination is out of bound, figure out the closest
     * in-bounds point and go to that, then to the real origin/destination.
     */
    std::vector<tripoint> ret;
 
    if( f == t || !inbounds( f ) ) {
        return ret;
    }
 
    if( !inbounds( t ) ) {
        tripoint clipped = t;
        clip_to_bounds( clipped );
        return route( f, clipped, settings, pre_closed );
    }
    // First, check for a simple straight line on flat ground
    // Except when the line contains a pre-closed tile - we need to do regular pathing then
    static const auto non_normal = PF_SLOW | PF_WALL | PF_VEHICLE | PF_TRAP | PF_SHARP;
    if( f.z == t.z ) {
        const auto line_path = line_to( f, t );
        const auto &pf_cache = get_pathfinding_cache_ref( f.z );
        // Check all points for any special case (including just hard terrain)
        if( !( pf_cache.special[f.x][f.y] & non_normal ) &&
        std::all_of( line_path.begin(), line_path.end(), [&pf_cache]( const tripoint & p ) {
        return !( pf_cache.special[p.x][p.y] & non_normal );
        } ) ) {
            const std::set<tripoint> sorted_line( line_path.begin(), line_path.end() );
 
            if( is_disjoint( sorted_line, pre_closed ) ) {
                return line_path;
            }
        }
    }
 
    // If expected path length is greater than max distance, allow only line path, like above
    if( rl_dist( f, t ) > settings.max_dist ) {
        return ret;
    }
 
    int max_length = settings.max_length;
    int bash = settings.bash_strength;
    int climb_cost = settings.climb_cost;
    bool doors = settings.allow_open_doors;
    bool trapavoid = settings.avoid_traps;
    bool roughavoid = settings.avoid_rough_terrain;
    bool sharpavoid = settings.avoid_sharp;
 
    const int pad = 16;  // Should be much bigger - low value makes pathfinders dumb!
    int minx = std::min( f.x, t.x ) - pad;
    int miny = std::min( f.y, t.y ) - pad;
    // TODO: Make this way bigger
    int minz = std::min( f.z, t.z );
    int maxx = std::max( f.x, t.x ) + pad;
    int maxy = std::max( f.y, t.y ) + pad;
    // Same TODO: as above
    int maxz = std::max( f.z, t.z );
    clip_to_bounds( minx, miny, minz );
    clip_to_bounds( maxx, maxy, maxz );
 
    pathfinder pf( point( minx, miny ), point( maxx, maxy ) );
    // Make NPCs not want to path through player
    // But don't make player pathing stop working
    for( const auto &p : pre_closed ) {
        if( p.x >= minx && p.x < maxx && p.y >= miny && p.y < maxy ) {
            pf.close_point( p );
        }
    }
 
    // Start and end must not be closed
    pf.unclose_point( f );
    pf.unclose_point( t );
    pf.add_point( 0, 0, f, f );
 
    bool done = false;
 
    do {
        auto cur = pf.get_next();
 
        const int parent_index = flat_index( cur );
        auto &layer = pf.get_layer( cur.z );
        auto &cur_state = layer.state[parent_index];
        if( cur_state == ASL_CLOSED ) {
            continue;
        }
 
        if( layer.gscore[parent_index] > max_length ) {
            // Shortest path would be too long, return empty vector
            return std::vector<tripoint>();
        }
 
        if( cur == t ) {
            done = true;
            break;
        }
 
        cur_state = ASL_CLOSED;
 
        const auto &pf_cache = get_pathfinding_cache_ref( cur.z );
        const auto cur_special = pf_cache.special[cur.x][cur.y];
 
        int cur_part;
        const vehicle *cur_veh = veh_at_internal( cur, cur_part );
 
        // 7 3 5
        // 1 . 2
        // 6 4 8
        constexpr std::array<int, 8> x_offset{{ -1,  1,  0,  0,  1, -1, -1, 1 }};
        constexpr std::array<int, 8> y_offset{{  0,  0, -1,  1, -1,  1, -1, 1 }};
        for( size_t i = 0; i < 8; i++ ) {
            const tripoint p( cur.x + x_offset[i], cur.y + y_offset[i], cur.z );
            const int index = flat_index( p );
 
            // TODO: Remove this and instead have sentinels at the edges
            if( p.x < minx || p.x >= maxx || p.y < miny || p.y >= maxy ) {
                continue;
            }
 
            if( layer.state[index] == ASL_CLOSED ) {
                continue;
            }
 
            int part = -1;
            const vehicle *veh = veh_at_internal( p, part );
            if( cur_veh &&
                !cur_veh->allowed_move( cur_veh->tripoint_to_mount( cur ), cur_veh->tripoint_to_mount( p ) ) ) {
                //Trying to squeeze through a vehicle hole, skip this movement but don't close the tile as other paths may lead to it
                continue;
            }
 
            if( veh && veh != cur_veh &&
                !veh->allowed_move( veh->tripoint_to_mount( cur ), veh->tripoint_to_mount( p ) ) ) {
                //Same as above but moving into rather than out of a vehicle
                continue;
            }
 
            // Penalize for diagonals or the path will look "unnatural"
            int newg = layer.gscore[parent_index] + ( ( cur.x != p.x && cur.y != p.y ) ? 1 : 0 );
 
            const auto p_special = pf_cache.special[p.x][p.y];
            // TODO: De-uglify, de-huge-n
            if( !( p_special & non_normal ) ) {
                // Boring flat dirt - the most common case above the ground
                newg += 2;
            } else {
                if( roughavoid ) {
                    layer.state[index] = ASL_CLOSED; // Close all rough terrain tiles
                    continue;
                }
 
                const maptile &tile = maptile_at_internal( p );
                const auto &terrain = tile.get_ter_t();
                const auto &furniture = tile.get_furn_t();
 
                const int cost = move_cost_internal( furniture, terrain, veh, part );
                // Don't calculate bash rating unless we intend to actually use it
                const int rating = ( bash == 0 || cost != 0 ) ? -1 :
                                   bash_rating_internal( bash, furniture, terrain, false, veh, part );
 
                if( cost == 0 && rating <= 0 && ( !doors || !terrain.open || !furniture.open ) && veh == nullptr &&
                    climb_cost <= 0 ) {
                    layer.state[index] = ASL_CLOSED; // Close it so that next time we won't try to calculate costs
                    continue;
                }
 
                newg += cost;
                if( cost == 0 ) {
                    if( climb_cost > 0 && p_special & PF_CLIMBABLE ) {
                        // Climbing fences
                        newg += climb_cost;
                    } else if( doors && ( terrain.open || furniture.open ) &&
                               ( !terrain.has_flag( "OPENCLOSE_INSIDE" ) || !furniture.has_flag( "OPENCLOSE_INSIDE" ) ||
                                 !is_outside( cur ) ) ) {
                        // Only try to open INSIDE doors from the inside
                        // To open and then move onto the tile
                        newg += 4;
                    } else if( veh != nullptr ) {
                        const auto vpobst = vpart_position( const_cast<vehicle &>( *veh ), part ).obstacle_at_part();
                        part = vpobst ? vpobst->part_index() : -1;
                        int dummy = -1;
                        if( doors && veh->part_flag( part, VPFLAG_OPENABLE ) &&
                            ( !veh->part_flag( part, "OPENCLOSE_INSIDE" ) ||
                              veh_at_internal( cur, dummy ) == veh ) ) {
                            // Handle car doors, but don't try to path through curtains
                            newg += 10; // One turn to open, 4 to move there
                        } else if( part >= 0 && bash > 0 ) {
                            // Car obstacle that isn't a door
                            // TODO: Account for armor
                            int hp = veh->cpart( part ).hp();
                            if( hp / 20 > bash ) {
                                // Threshold damage thing means we just can't bash this down
                                layer.state[index] = ASL_CLOSED;
                                continue;
                            } else if( hp / 10 > bash ) {
                                // Threshold damage thing means we will fail to deal damage pretty often
                                hp *= 2;
                            }
 
                            newg += 2 * hp / bash + 8 + 4;
                        } else if( part >= 0 ) {
                            if( !doors || !veh->part_flag( part, VPFLAG_OPENABLE ) ) {
                                // Won't be openable, don't try from other sides
                                layer.state[index] = ASL_CLOSED;
                            }
 
                            continue;
                        }
                    } else if( rating > 1 ) {
                        // Expected number of turns to bash it down, 1 turn to move there
                        // and 5 turns of penalty not to trash everything just because we can
                        newg += ( 20 / rating ) + 2 + 10;
                    } else if( rating == 1 ) {
                        // Desperate measures, avoid whenever possible
                        newg += 500;
                    } else {
                        // Unbashable and unopenable from here
                        if( !doors || !terrain.open || !furniture.open ) {
                            // Or anywhere else for that matter
                            layer.state[index] = ASL_CLOSED;
                        }
 
                        continue;
                    }
                }
 
                if( trapavoid && p_special & PF_TRAP ) {
                    const auto &ter_trp = terrain.trap.obj();
                    const auto &trp = ter_trp.is_benign() ? tile.get_trap_t() : ter_trp;
                    if( !trp.is_benign() ) {
                        // For now make them detect all traps
                        if( has_zlevels() && terrain.has_flag( TFLAG_NO_FLOOR ) ) {
                            // Special case - ledge in z-levels
                            // Warning: really expensive, needs a cache
                            if( valid_move( p, tripoint( p.xy(), p.z - 1 ), false, true ) ) {
                                tripoint below( p.xy(), p.z - 1 );
                                if( !has_flag( TFLAG_NO_FLOOR, below ) ) {
                                    // Otherwise this would have been a huge fall
                                    auto &layer = pf.get_layer( p.z - 1 );
                                    // From cur, not p, because we won't be walking on air
                                    pf.add_point( layer.gscore[parent_index] + 10,
                                                  layer.score[parent_index] + 10 + 2 * rl_dist( below, t ),
                                                  cur, below );
                                }
 
                                // Close p, because we won't be walking on it
                                layer.state[index] = ASL_CLOSED;
                                continue;
                            }
                        } else if( trapavoid ) {
                            // Otherwise it's walkable
                            newg += 500;
                        }
                    }
                }
 
                if( sharpavoid && p_special & PF_SHARP ) {
                    layer.state[index] = ASL_CLOSED; // Avoid sharp things
                }
 
            }
 
            // If not visited, add as open
            // If visited, add it only if we can do so with better score
            if( layer.state[index] == ASL_NONE || newg < layer.gscore[index] ) {
                pf.add_point( newg, newg + 2 * rl_dist( p, t ), cur, p );
            }
        }
 
        if( !has_zlevels() || !( cur_special & PF_UPDOWN ) || !settings.allow_climb_stairs ) {
            // The part below is only for z-level pathing
            continue;
        }
 
        const maptile &parent_tile = maptile_at_internal( cur );
        const auto &parent_terrain = parent_tile.get_ter_t();
        if( settings.allow_climb_stairs && cur.z > minz && parent_terrain.has_flag( TFLAG_GOES_DOWN ) ) {
            tripoint dest( cur.xy(), cur.z - 1 );
            if( vertical_move_destination<TFLAG_GOES_UP>( *this, dest ) ) {
                auto &layer = pf.get_layer( dest.z );
                pf.add_point( layer.gscore[parent_index] + 2,
                              layer.score[parent_index] + 2 * rl_dist( dest, t ),
                              cur, dest );
            }
        }
        if( settings.allow_climb_stairs && cur.z < maxz && parent_terrain.has_flag( TFLAG_GOES_UP ) ) {
            tripoint dest( cur.xy(), cur.z + 1 );
            if( vertical_move_destination<TFLAG_GOES_DOWN>( *this, dest ) ) {
                auto &layer = pf.get_layer( dest.z );
                pf.add_point( layer.gscore[parent_index] + 2,
                              layer.score[parent_index] + 2 * rl_dist( dest, t ),
                              cur, dest );
            }
        }
        if( cur.z < maxz && parent_terrain.has_flag( TFLAG_RAMP ) &&
            valid_move( cur, tripoint( cur.xy(), cur.z + 1 ), false, true ) ) {
            auto &layer = pf.get_layer( cur.z + 1 );
            for( size_t it = 0; it < 8; it++ ) {
                const tripoint above( cur.x + x_offset[it], cur.y + y_offset[it], cur.z + 1 );
                pf.add_point( layer.gscore[parent_index] + 4,
                              layer.score[parent_index] + 4 + 2 * rl_dist( above, t ),
                              cur, above );
            }
        }
        if( cur.z < maxz && parent_terrain.has_flag( TFLAG_RAMP_UP ) &&
            valid_move( cur, tripoint( cur.xy(), cur.z + 1 ), false, true, true ) ) {
            auto &layer = pf.get_layer( cur.z + 1 );
            for( size_t it = 0; it < 8; it++ ) {
                const tripoint above( cur.x + x_offset[it], cur.y + y_offset[it], cur.z + 1 );
                pf.add_point( layer.gscore[parent_index] + 4,
                              layer.score[parent_index] + 4 + 2 * rl_dist( above, t ),
                              cur, above );
            }
        }
        if( cur.z > minz && parent_terrain.has_flag( TFLAG_RAMP_DOWN ) &&
            valid_move( cur, tripoint( cur.xy(), cur.z - 1 ), false, true, true ) ) {
            auto &layer = pf.get_layer( cur.z - 1 );
            for( size_t it = 0; it < 8; it++ ) {
                const tripoint below( cur.x + x_offset[it], cur.y + y_offset[it], cur.z - 1 );
                pf.add_point( layer.gscore[parent_index] + 4,
                              layer.score[parent_index] + 4 + 2 * rl_dist( below, t ),
                              cur, below );
            }
        }
 
    } while( !done && !pf.empty() );
 
    if( done ) {
        ret.reserve( rl_dist( f, t ) * 2 );
        tripoint cur = t;
        // Just to limit max distance, in case something weird happens
        for( int fdist = max_length; fdist != 0; fdist-- ) {
            const int cur_index = flat_index( cur );
            const auto &layer = pf.get_layer( cur.z );
            const tripoint &par = layer.parent[cur_index];
            if( cur == f ) {
                break;
            }
 
            ret.push_back( cur );
            // Jumps are acceptable on 1 z-level changes
            // This is because stairs teleport the player too
            if( rl_dist( cur, par ) > 1 && std::abs( cur.z - par.z ) != 1 ) {
                debugmsg( "Jump in our route!  %d:%d:%d->%d:%d:%d",
                          cur.x, cur.y, cur.z, par.x, par.y, par.z );
                return ret;
            }
 
            cur = par;
        }
 
        std::reverse( ret.begin(), ret.end() );
    }
 
    return ret;
}

Referenced by add_item_or_charges(), Character::can_mount(), game::handle_action(), game::list_items(), game::look_around(), route(), game::try_get_left_click_action(), and npc::update_path().

◆ save()

void map::save ( )

Add currently loaded submaps (in grid) to the mapbuffer.

They will than be stored by that class and can be loaded from that class. This can be called several times, the mapbuffer takes care of adding the same submap several times. It should only be called after the map has been loaded. Submaps that have been loaded from the mapbuffer (and not generated) are already stored in the mapbuffer. TODO: determine if this is really needed? Submaps are already in the mapbuffer if they have been loaded from disc and the are added by map::generate, too. So when do they not appear in the mapbuffer?

Definition at line 6735 of file map.cpp.

{
    for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
        for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
            if( zlevels ) {
                for( int gridz = -OVERMAP_DEPTH; gridz <= OVERMAP_HEIGHT; gridz++ ) {
                    saven( tripoint( gridx, gridy, gridz ) );
                }
            } else {
                saven( tripoint( gridx, gridy, abs_sub.z ) );
            }
        }
    }
}

References abs_sub, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, saven(), tripoint::z, and zlevels.

◆ saven()

void map::saven ( const tripoint & grid )

protected

Definition at line 7078 of file map.cpp.

{
    dbg( DL::Debug ) << "map::saven( world=" << abs_sub << ", grid=" << grid << " )";
    const int gridn = get_nonant( grid );
    submap *submap_to_save = getsubmap( gridn );
    if( submap_to_save == nullptr || submap_to_save->get_ter( point_zero ) == t_null ) {
        // This is a serious error and should be signaled as soon as possible
        debugmsg( "map::saven grid (%s) %s!", grid.to_string(),
                  submap_to_save == nullptr ? "null" : "uninitialized" );
        return;
    }
 
    const tripoint abs = abs_sub.xy() + grid;
 
    if( !zlevels && grid.z != abs_sub.z ) {
        debugmsg( "Tried to save submap (%d,%d,%d) as (%d,%d,%d), which isn't supported in non-z-level builds",
                  abs.x, abs.y, abs_sub.z, abs.x, abs.y, grid.z );
    }
 
    dbg( DL::Debug ) << "map::saven abs: " << abs << "  gridn: " << gridn;
 
    // An edge case: restock_fruits relies on last_touched, so we must call it before save
    if( season_of_year( calendar::turn ) != season_of_year( submap_to_save->last_touched ) ) {
        const time_duration time_since_last_actualize = calendar::turn - submap_to_save->last_touched;
        for( int x = 0; x < SEEX; x++ ) {
            for( int y = 0; y < SEEY; y++ ) {
                const tripoint pnt = sm_to_ms_copy( grid ) + point( x, y );
                restock_fruits( pnt, time_since_last_actualize );
            }
        }
    }
 
    submap_to_save->last_touched = calendar::turn;
    MAPBUFFER.add_submap( abs, submap_to_save );
}

References abs_sub, mapbuffer::add_submap(), dbg, Debug, debugmsg, get_nonant(), submap::get_ter(), getsubmap(), grid, submap::last_touched, MAPBUFFER, point_zero, restock_fruits(), season_of_year(), SEEX, SEEY, sm_to_ms_copy(), t_null, calendar::turn, tripoint::xy(), tripoint::z, and zlevels.

Referenced by generate(), and save().

◆ scent_blockers()

void map::scent_blockers	(	std::array< std::array< char, MAPSIZE_X >, MAPSIZE_Y > &	scent_transfer,
		point	min,
		point	max
	)

Build the map of scent-resistant tiles.

Should be way faster than if done in game.cpp using public map functions.

Definition at line 8702 of file map.cpp.

{
    auto reduce = TFLAG_REDUCE_SCENT;
    auto block = TFLAG_NO_SCENT;
    auto fill_values = [&]( const tripoint & gp, const submap * sm, point  lp ) {
        // We need to generate the x/y coordinates, because we can't get them "for free"
        const point p = lp + sm_to_ms_copy( gp.xy() );
        if( sm->get_ter( lp ).obj().has_flag( block ) ) {
            scent_transfer[p.x][p.y] = 0;
        } else if( sm->get_ter( lp ).obj().has_flag( reduce ) ||
                   sm->get_furn( lp ).obj().has_flag( reduce ) ) {
            scent_transfer[p.x][p.y] = 1;
        } else {
            scent_transfer[p.x][p.y] = 5;
        }
 
        return ITER_CONTINUE;
    };
 
    function_over( tripoint( min, abs_sub.z ), tripoint( max, abs_sub.z ), fill_values );
 
    const inclusive_rectangle<point> local_bounds( min, max );
 
    // Now vehicles
 
    auto vehs = get_vehicles();
    for( auto &wrapped_veh : vehs ) {
        vehicle &veh = *( wrapped_veh.v );
        for( const vpart_reference &vp : veh.get_any_parts( VPFLAG_OBSTACLE ) ) {
            const tripoint part_pos = vp.pos();
            if( local_bounds.contains( part_pos.xy() ) && scent_transfer[part_pos.x][part_pos.y] == 5 ) {
                scent_transfer[part_pos.x][part_pos.y] = 1;
            }
        }
 
        // Doors, but only the closed ones
        for( const vpart_reference &vp : veh.get_any_parts( VPFLAG_OPENABLE ) ) {
            if( vp.part().open ) {
                continue;
            }
 
            const tripoint part_pos = vp.pos();
            if( local_bounds.contains( part_pos.xy() ) && scent_transfer[part_pos.x][part_pos.y] == 5 ) {
                scent_transfer[part_pos.x][part_pos.y] = 1;
            }
        }
    }
}

References abs_sub, inclusive_rectangle< Point, >::contains(), function_over(), vehicle::get_any_parts(), get_vehicles(), ITER_CONTINUE, coords::sm, sm_to_ms_copy(), TFLAG_NO_SCENT, TFLAG_REDUCE_SCENT, VPFLAG_OBSTACLE, VPFLAG_OPENABLE, point::x, tripoint::x, tripoint::xy(), point::y, tripoint::y, and tripoint::z.

Referenced by scent_map::update().

◆ sees() [1/2]

bool map::sees	(	const tripoint &	F,
		const tripoint &	T,
		int	range
	)		const

Returns whether F sees T with a view range of range.

Definition at line 6270 of file map.cpp.

{
    int dummy = 0;
    return sees( F, T, range, dummy );
}

References range, and sees().

Referenced by find_clear_path(), sees(), shake_vehicle(), shoot(), and spawn_monsters_submap_group().

◆ sees() [2/2]

bool map::sees	(	const tripoint &	F,
		const tripoint &	T,
		int	range,
		int &	bresenham_slope
	)		const

private

Don't expose the slope adjust outside map functions.

This one is internal-only, we don't want to expose the slope tweaking ickiness outside the map class.

Parameters

F	Thing doing the seeing
T	Thing being seen
range	Vision range of F
bresenham_slope	Indicates the start offset of Bresenham line used to connect the two points, and may subsequently be used to form a path between them. Set to zero if the function returns false.

Definition at line 6279 of file map.cpp.

{
    if( ( range >= 0 && range < rl_dist( F, T ) ) ||
        !inbounds( T ) ) {
        bresenham_slope = 0;
        return false; // Out of range!
    }
    // Cannonicalize the order of the tripoints so the cache is reflexive.
    const tripoint &min = F < T ? F : T;
    const tripoint &max = !( F < T ) ? F : T;
    // A little gross, just pack the values into a point.
    const point key(
        min.x << 16 | min.y << 8 | ( min.z + OVERMAP_DEPTH ),
        max.x << 16 | max.y << 8 | ( max.z + OVERMAP_DEPTH )
    );
    char cached = skew_vision_cache.get( key, -1 );
    if( cached >= 0 ) {
        return cached > 0;
    }
 
    bool visible = true;
 
    // Ugly `if` for now
    if( !fov_3d || F.z == T.z ) {
 
        point last_point = F.xy();
        bresenham( F.xy(), T.xy(), bresenham_slope,
        [this, &visible, &T, &last_point]( point  new_point ) {
            // Exit before checking the last square, it's still visible even if opaque.
            if( new_point.x == T.x && new_point.y == T.y ) {
                return false;
            }
            if( !this->is_transparent( tripoint( new_point, T.z ) ) ||
                obscured_by_vehicle_rotation( tripoint( last_point, T.z ), tripoint( new_point, T.z ) ) ) {
                visible = false;
                return false;
            }
            last_point = new_point;
            return true;
        } );
        skew_vision_cache.insert( 100000, key, visible ? 1 : 0 );
        return visible;
    }
 
    tripoint last_point = F;
    bresenham( F, T, bresenham_slope, 0,
    [this, &visible, &T, &last_point]( const tripoint & new_point ) {
        // Exit before checking the last square if it's not a vertical transition,
        // it's still visible even if opaque.
        if( new_point == T && last_point.z == T.z ) {
            return false;
        }
 
        // TODO: Allow transparent floors (and cache them!)
        if( new_point.z == last_point.z ) {
            if( !this->is_transparent( new_point ) || obscured_by_vehicle_rotation( last_point, new_point ) ) {
                visible = false;
                return false;
            }
        } else {
            const int max_z = std::max( new_point.z, last_point.z );
            if( ( has_floor_or_support( {new_point.xy(), max_z} ) ||
                  !is_transparent( {new_point.xy(), last_point.z} ) ) &&
                ( has_floor_or_support( {last_point.xy(), max_z} ) ||
                  !is_transparent( {last_point.xy(), new_point.z} ) ) ) {
                visible = false;
                return false;
            }
        }
 
        last_point = new_point;
        return true;
    } );
    skew_vision_cache.insert( 100000, key, visible ? 1 : 0 );
    return visible;
}

References bresenham(), fov_3d, inbounds(), obscured_by_vehicle_rotation(), OVERMAP_DEPTH, range, rl_dist(), skew_vision_cache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

◆ sees_some_items() [1/2]

bool map::sees_some_items	(	const tripoint &	p,
		const Creature &	who
	)		const

Check if creature can see some items at p.

Includes:

check for items at this location (has_items(p))
check for SEALED flag (sealed furniture/terrain makes items not visible under any circumstances).
check for CONTAINER flag (makes items only visible when the creature is at p or at an adjacent square).

Definition at line 4856 of file map.cpp.

{
    // Can only see items if there are any items.
    return has_items( p ) && could_see_items( p, who.pos() );
}

References could_see_items(), has_items(), and Creature::pos().

Referenced by game::butcher(), editmap::draw_main_ui_overlay(), draw_maptile(), game::find_nearby_items(), and game::print_items_info().

◆ sees_some_items() [2/2]

bool map::sees_some_items	(	const tripoint &	p,
		const tripoint &	from
	)		const

Definition at line 4862 of file map.cpp.

{
    return has_items( p ) && could_see_items( p, from );
}

References could_see_items(), and has_items().

◆ set() [1/2]

void map::set	(	const tripoint &	p,
		const ter_id &	new_terrain,
		const furn_id &	new_furniture
	)

Definition at line 1384 of file map.cpp.

{
    furn_set( p, new_furniture );
    ter_set( p, new_terrain );
}

References furn_set(), and ter_set().

Referenced by farm_action(), talk_function::field_plant(), and mapgen_function_json_base::formatted_set_incredibly_simple().

◆ set() [2/2]

void map::set	(	point	p,
		const ter_id &	new_terrain,
		const furn_id &	new_furniture
	)

inline

Definition at line 774 of file map.h.

                                                                                     {
            furn_set( p, new_furniture );
            ter_set( p, new_terrain );
        }

References furn_set(), and ter_set().

◆ set_abs_sub()

void map::set_abs_sub ( const tripoint & p )

protected

Sets abs_sub, see there.

Uses the same coordinate system as abs_sub.

Definition at line 8428 of file map.cpp.

{
    abs_sub = p;
}

References abs_sub.

Referenced by fake_map::fake_map(), generate(), load(), shift(), and vertical_shift().

◆ set_field_age()

time_duration map::set_field_age	(	const tripoint &	p,
		const field_type_id &	type,
		const time_duration &	age,
		bool	isoffset = `false`
	)

Set age of field entry at point.

Parameters

p	Location of field
type	ID of field
age	New age of specified field
isoffset	If true, the given age value is added to the existing value, if false, the existing age is ignored and overridden.

Returns: resulting age or -1_turns if not present (does not create a new field).

Definition at line 5460 of file map.cpp.

{
    if( field_entry *const field_ptr = get_field( p, type ) ) {
        return field_ptr->set_field_age( ( isoffset ? field_ptr->get_field_age() : 0_turns ) + age );
    }
    return -1_turns;
}

References get_field(), and type.

Referenced by game::grabbed_furn_move(), mod_field_age(), and game::walk_move().

◆ set_field_intensity()

int map::set_field_intensity	(	const tripoint &	p,
		const field_type_id &	type,
		int	new_intensity,
		bool	isoffset = `false`
	)

Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.

Parameters

p	Location of field
type	ID of field
new_intensity	New intensity of field
isoffset	If true, the given new_intensity value is added to the existing value, if false, the existing intensity is ignored and overridden.

Returns: resulting intensity, or 0 for not present (either removed or not created at all).

Definition at line 5473 of file map.cpp.

{
    field_entry *field_ptr = get_field( p, type );
    if( field_ptr != nullptr ) {
        int adj = ( isoffset ? field_ptr->get_field_intensity() : 0 ) + new_intensity;
        if( adj > 0 ) {
            field_ptr->set_field_intensity( adj );
            return adj;
        } else {
            remove_field( p, type );
            return 0;
        }
    } else if( 0 + new_intensity > 0 ) {
        return add_field( p, type, new_intensity ) ? new_intensity : 0;
    }
 
    return 0;
}

References add_field(), get_field(), field_entry::get_field_intensity(), remove_field(), field_entry::set_field_intensity(), and type.

Referenced by game::grabbed_furn_move(), mod_field_intensity(), and game::walk_move().

◆ set_floor_cache_dirty()

void map::set_floor_cache_dirty ( const int zlev )

Definition at line 236 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        get_cache( zlev ).floor_cache_dirty = true;
    }
}

References level_cache::floor_cache_dirty, get_cache(), and inbounds_z().

Referenced by furn_set(), loadn(), on_vehicle_moved(), DefaultRemovePartHandler::set_floor_cache_dirty(), and ter_set().

◆ set_graffiti()

void map::set_graffiti	(	const tripoint &	p,
		const std::string &	contents
	)

Definition at line 7949 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
    point l;
    submap *const current_submap = get_submap_at( p, l );
    current_submap->set_graffiti( l, contents );
}

References get_submap_at(), inbounds(), and submap::set_graffiti().

Referenced by jmapgen_graffiti::apply().

◆ set_memory_seen_cache_dirty()

void map::set_memory_seen_cache_dirty ( const tripoint & p )

Definition at line 8982 of file map.cpp.

{
    const int offset = p.x + p.y * MAPSIZE_Y;
    if( offset >= 0 && offset < MAPSIZE_X * MAPSIZE_Y ) {
        get_cache( p.z ).map_memory_seen_cache.reset( offset );
    }
}

References get_cache(), level_cache::map_memory_seen_cache, MAPSIZE_X, MAPSIZE_Y, tripoint::x, tripoint::y, and tripoint::z.

Referenced by furn_set(), and ter_set().

◆ set_outside_cache_dirty()

void map::set_outside_cache_dirty ( const int zlev )

Definition at line 222 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        get_cache( zlev ).outside_cache_dirty = true;
    }
}

References get_cache(), inbounds_z(), and level_cache::outside_cache_dirty.

Referenced by draw_fill_background(), furn_set(), loadn(), on_vehicle_moved(), ter_set(), and game::vertical_shift().

◆ set_pathfinding_cache_dirty()

void map::set_pathfinding_cache_dirty ( int zlev )

Definition at line 8945 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        get_pathfinding_cache( zlev ).dirty = true;
    }
}

References pathfinding_cache::dirty, get_pathfinding_cache(), and inbounds_z().

Referenced by add_field(), draw_fill_background(), furn_set(), loadn(), on_vehicle_moved(), remove_field(), and ter_set().

◆ set_radiation() [1/2]

void map::set_radiation	(	const tripoint &	p,
		int	value
	)

Definition at line 4166 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    current_submap->set_radiation( l, value );
}

References get_submap_at(), inbounds(), and submap::set_radiation().

Referenced by jmapgen_setmap::apply(), create_anomaly(), draw_lab(), mapgen_crater(), mapgen_null(), mapgen_test(), and set_radiation().

◆ set_radiation() [2/2]

void map::set_radiation	(	point	p,
		const int	value
	)

inline

Definition at line 1156 of file map.h.

                                                       {
            set_radiation( tripoint( p, abs_sub.z ), value );
        }

References abs_sub, set_radiation(), and tripoint::z.

◆ set_seen_cache_dirty() [1/2]

void map::set_seen_cache_dirty ( const int zlevel )

Definition at line 243 of file map.cpp.

{
    if( inbounds_z( zlevel ) ) {
        level_cache &cache = get_cache( zlevel );
        cache.seen_cache_dirty = true;
    }
}

References get_cache(), inbounds_z(), and level_cache::seen_cache_dirty.

◆ set_seen_cache_dirty() [2/2]

void map::set_seen_cache_dirty ( const tripoint change_location )

Definition at line 208 of file map.cpp.

{
    if( inbounds( change_location ) ) {
        level_cache &cache = get_cache( change_location.z );
        if( cache.seen_cache_dirty ) {
            return;
        }
        if( cache.seen_cache[change_location.x][change_location.y] != 0.0 ||
            cache.camera_cache[change_location.x][change_location.y] != 0.0 ) {
            cache.seen_cache_dirty = true;
        }
    }
}

References level_cache::camera_cache, get_cache(), inbounds(), level_cache::seen_cache, level_cache::seen_cache_dirty, tripoint::x, tripoint::y, and tripoint::z.

Referenced by add_field(), draw_fill_background(), furn_set(), loadn(), process_fields_in_submap(), remove_field(), avatar::set_movement_mode(), ter_set(), and weather_manager::update_weather().

◆ set_signage()

void map::set_signage	(	const tripoint &	p,
		const std::string &	message
	)		const

Definition at line 4131 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    current_submap->set_signage( l, message );
}

References get_submap_at(), inbounds(), mapgen_defer::message, and submap::set_signage().

Referenced by jmapgen_sign::apply(), MapExtras::mx_grave(), and MapExtras::mx_minefield().

◆ set_suspension_cache_dirty()

void map::set_suspension_cache_dirty ( const int zlev )

Definition at line 229 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        get_cache( zlev ).suspension_cache_dirty = true;
    }
}

References get_cache(), inbounds_z(), and level_cache::suspension_cache_dirty.

Referenced by loadn(), and ter_set().

◆ set_temperature() [1/2]

void map::set_temperature	(	const tripoint &	p,
		int	temperature
	)

Definition at line 4200 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    get_submap_at( p )->set_temperature( new_temperature );
}

References get_submap_at(), inbounds(), and submap::set_temperature().

Referenced by draw_lab(), and set_temperature().

◆ set_temperature() [2/2]

void map::set_temperature	(	point	p,
		int	new_temperature
	)

inline

Definition at line 1173 of file map.h.

                                                             {
            set_temperature( tripoint( p, abs_sub.z ), new_temperature );
        }

References abs_sub, set_temperature(), and tripoint::z.

◆ set_transparency_cache_dirty() [1/2]

void map::set_transparency_cache_dirty ( const int zlev )

Sets a dirty flag on the a given cache.

If this isn't set, it's just assumed that the cache hasn't changed and doesn't need to be updated.

Definition at line 201 of file map.cpp.

{
    if( inbounds_z( zlev ) ) {
        get_cache( zlev ).transparency_cache_dirty.set();
    }
}

References get_cache(), inbounds_z(), and level_cache::transparency_cache_dirty.

Referenced by add_field(), draw_fill_background(), furn_set(), loadn(), on_vehicle_moved(), process_fields_in_submap(), remove_field(), ter_set(), weather_manager::update_weather(), and game::vertical_shift().

◆ set_transparency_cache_dirty() [2/2]

void map::set_transparency_cache_dirty ( const tripoint & p )

Definition at line 251 of file map.cpp.

{
    if( inbounds( p ) ) {
        const tripoint smp = ms_to_sm_copy( p );
        get_cache( smp.z ).transparency_cache_dirty.set( smp.x * MAPSIZE + smp.y );
    }
}

References get_cache(), inbounds(), MAPSIZE, ms_to_sm_copy(), level_cache::transparency_cache_dirty, tripoint::x, tripoint::y, and tripoint::z.

◆ setsubmap()

void map::setsubmap	(	size_t	grididx,
		submap *	smap
	)

protected

Set the submap pointer in grid at the give index.

This is the inverse of getsubmap, any existing pointer is overwritten. The index must be valid. The given submap pointer must not be null.

Definition at line 8447 of file map.cpp.

{
    if( grididx >= grid.size() ) {
        debugmsg( "Tried to access invalid grid index %d", grididx );
        return;
    } else if( smap == nullptr ) {
        debugmsg( "Tried to set NULL submap pointer at index %d", grididx );
        return;
    }
    grid[grididx] = smap;
}

References debugmsg, and grid.

Referenced by copy_grid(), fake_map::fake_map(), generate(), and loadn().

◆ shake_vehicle()

units::angle map::shake_vehicle	(	vehicle &	veh,
		int	velocity_before,
		units::angle	direction
	)

Strength reduces chance of being thrown from your seat when not wearing a seatbelt Strength reduces chance of being thrown from your seat when not wearing a seatbelt Dexterity reduces chance of losing control of vehicle when shaken Driving reduces chance of losing control of vehicle when shaken Strength reduces distance thrown from seat in a vehicle impact

Definition at line 1651 of file vehicle_move.cpp.

{
    const int d_vel = std::abs( veh.velocity - velocity_before ) / 100;
 
    std::vector<rider_data> riders = veh.get_riders();
 
    units::angle coll_turn = 0_degrees;
    for( const rider_data &r : riders ) {
        const int ps = r.prt;
        Creature *rider = r.psg;
        if( rider == nullptr ) {
            debugmsg( "throw passenger: empty passenger at part %d", ps );
            continue;
        }
 
        const tripoint part_pos = veh.global_part_pos3( ps );
        if( rider->pos() != part_pos ) {
            debugmsg( "throw passenger: passenger at %d,%d,%d, part at %d,%d,%d",
                      rider->posx(), rider->posy(), rider->posz(),
                      part_pos.x, part_pos.y, part_pos.z );
            veh.part( ps ).remove_flag( vehicle_part::passenger_flag );
            continue;
        }
 
        player *psg = dynamic_cast<player *>( rider );
        monster *pet = dynamic_cast<monster *>( rider );
 
        bool throw_from_seat = false;
        int move_resist = 1;
        if( psg ) {
            ///\EFFECT_STR reduces chance of being thrown from your seat when not wearing a seatbelt
            move_resist = psg->str_cur * 150 + 500;
        } else {
            int pet_resist = 0;
            if( pet != nullptr ) {
                pet_resist = static_cast<int>( to_kilogram( pet->get_weight() ) * 200 );
            }
            move_resist = std::max( 100, pet_resist );
        }
        if( veh.part_with_feature( ps, VPFLAG_SEATBELT, true ) == -1 ) {
            ///\EFFECT_STR reduces chance of being thrown from your seat when not wearing a seatbelt
            throw_from_seat = d_vel * rng( 80, 120 ) > move_resist;
        }
 
        // Damage passengers if d_vel is too high
        if( !throw_from_seat && ( 10 * d_vel ) > 6 * rng( 50, 100 ) ) {
            const int dmg = d_vel * rng( 70, 100 ) / 400;
            if( psg ) {
                psg->hurtall( dmg, nullptr );
                psg->add_msg_player_or_npc( m_bad,
                                            _( "You take %d damage by the power of the impact!" ),
                                            _( "<npcname> takes %d damage by the power of the "
                                               "impact!" ),  dmg );
            } else {
                pet->apply_damage( nullptr, bodypart_id( "torso" ), dmg );
            }
        }
 
        if( psg && veh.player_in_control( *psg ) ) {
            const int lose_ctrl_roll = rng( 0, d_vel );
            ///\EFFECT_DEX reduces chance of losing control of vehicle when shaken
 
            ///\EFFECT_DRIVING reduces chance of losing control of vehicle when shaken
            if( lose_ctrl_roll > psg->dex_cur * 2 + psg->get_skill_level( skill_driving ) * 3 ) {
                psg->add_msg_player_or_npc( m_warning,
                                            _( "You lose control of the %s." ),
                                            _( "<npcname> loses control of the %s." ), veh.name );
                int turn_amount = rng( 1, 3 ) * std::sqrt( std::abs( veh.velocity ) ) / 30;
                if( turn_amount < 1 ) {
                    turn_amount = 1;
                }
                units::angle turn_angle = std::min( turn_amount * 15_degrees, 120_degrees );
                coll_turn = one_in( 2 ) ? turn_angle : -turn_angle;
            }
        }
 
        if( throw_from_seat ) {
            if( psg ) {
                psg->add_msg_player_or_npc( m_bad,
                                            _( "You are hurled from the %s's seat by "
                                               "the power of the impact!" ),
                                            _( "<npcname> is hurled from the %s's seat by "
                                               "the power of the impact!" ), veh.name );
                unboard_vehicle( part_pos );
            } else if( get_player_character().sees( part_pos ) ) {
                add_msg( m_bad, _( "The %s is hurled from %s's by the power of the impact!" ),
                         pet->disp_name(), veh.name );
            }
            ///\EFFECT_STR reduces distance thrown from seat in a vehicle impact
            g->fling_creature( rider, direction + rng_float( -30_degrees, 30_degrees ),
                               std::max( 10, d_vel - move_resist / 100 ) );
        }
    }
 
    return coll_turn;
}

References _, add_msg(), player::add_msg_player_or_npc(), monster::apply_damage(), debugmsg, Character::dex_cur, monster::disp_name(), g, get_player_character(), vehicle::get_riders(), Character::get_skill_level(), monster::get_weight(), vehicle::global_part_pos3(), Character::hurtall(), m_bad, m_warning, vehicle::name, one_in(), vehicle::part(), vehicle::part_with_feature(), vehicle_part::passenger_flag, vehicle::player_in_control(), Creature::pos(), Creature::posx(), Creature::posy(), Creature::posz(), vehicle_part::remove_flag(), rng(), rng_float(), sees(), skill_driving, Character::str_cur, units::to_kilogram(), unboard_vehicle(), vehicle::velocity, VPFLAG_SEATBELT, tripoint::x, tripoint::y, and tripoint::z.

Referenced by move_vehicle().

◆ shift()

void map::shift ( point s )

Shift the map along the vector s.

This is like loading the map with coordinates derived from the current position of the map (abs_sub) plus the shift vector. Note: the map must have been loaded before this can be called.

Definition at line 6907 of file map.cpp.

{
    // Special case of 0-shift; refresh the map
    if( sp == point_zero ) {
        return; // Skip this?
    }
 
    if( std::abs( sp.x ) > 1 || std::abs( sp.y ) > 1 ) {
        debugmsg( "map::shift called with a shift of more than one submap" );
    }
 
    const tripoint abs = get_abs_sub();
 
    set_abs_sub( abs + sp );
 
    // if player is in vehicle, (s)he must be shifted with vehicle too
    if( g->u.in_vehicle ) {
        g->u.setx( g->u.posx() - sp.x * SEEX );
        g->u.sety( g->u.posy() - sp.y * SEEY );
    }
 
    g->shift_destination_preview( point( -sp.x * SEEX, -sp.y * SEEY ) );
 
    shift_traps( tripoint( sp, 0 ) );
 
    vehicle *remoteveh = g->remoteveh();
 
    const int zmin = zlevels ? -OVERMAP_DEPTH : abs.z;
    const int zmax = zlevels ? OVERMAP_HEIGHT : abs.z;
    for( int gridz = zmin; gridz <= zmax; gridz++ ) {
        for( vehicle *veh : get_cache( gridz ).vehicle_list ) {
            veh->zones_dirty = true;
        }
    }
 
    constexpr half_open_rectangle<point> boundaries_2d( point_zero, point( MAPSIZE_Y, MAPSIZE_X ) );
    const point shift_offset_pt( -sp.x * SEEX, -sp.y * SEEY );
 
    // Clear vehicle list and rebuild after shift
    clear_vehicle_cache( );
    // Shift the map sx submaps to the right and sy submaps down.
    // sx and sy should never be bigger than +/-1.
    // absx and absy are our position in the world, for saving/loading purposes.
    for( int gridz = zmin; gridz <= zmax; gridz++ ) {
        clear_vehicle_list( gridz );
        shift_bitset_cache<MAPSIZE_X, SEEX>( get_cache( gridz ).map_memory_seen_cache, sp );
        shift_bitset_cache<MAPSIZE, 1>( get_cache( gridz ).field_cache, sp );
        if( sp.x >= 0 ) {
            for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
                if( sp.y >= 0 ) {
                    for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
                        if( ( sp.x > 0 && gridx == 0 ) || ( sp.y > 0 && gridy == 0 ) ) {
                            submaps_with_active_items.erase( { abs.x + gridx, abs.y + gridy, gridz } );
                        }
                        if( gridx + sp.x < my_MAPSIZE && gridy + sp.y < my_MAPSIZE ) {
                            copy_grid( tripoint( gridx, gridy, gridz ),
                                       tripoint( gridx + sp.x, gridy + sp.y, gridz ) );
                            update_vehicle_list( get_submap_at_grid( {gridx, gridy, gridz} ), gridz );
                        } else {
                            loadn( tripoint( gridx, gridy, gridz ), true );
                        }
                    }
                } else { // sy < 0; work through it backwards
                    for( int gridy = my_MAPSIZE - 1; gridy >= 0; gridy-- ) {
                        if( ( sp.x > 0 && gridx == 0 ) || gridy == my_MAPSIZE - 1 ) {
                            submaps_with_active_items.erase( { abs.x + gridx, abs.y + gridy, gridz } );
                        }
                        if( gridx + sp.x < my_MAPSIZE && gridy + sp.y >= 0 ) {
                            copy_grid( tripoint( gridx, gridy, gridz ),
                                       tripoint( gridx + sp.x, gridy + sp.y, gridz ) );
                            update_vehicle_list( get_submap_at_grid( { gridx, gridy, gridz } ), gridz );
                        } else {
                            loadn( tripoint( gridx, gridy, gridz ), true );
                        }
                    }
                }
            }
        } else { // sx < 0; work through it backwards
            for( int gridx = my_MAPSIZE - 1; gridx >= 0; gridx-- ) {
                if( sp.y >= 0 ) {
                    for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
                        if( gridx == my_MAPSIZE - 1 || ( sp.y > 0 && gridy == 0 ) ) {
                            submaps_with_active_items.erase( { abs.x + gridx, abs.y + gridy, gridz } );
                        }
                        if( gridx + sp.x >= 0 && gridy + sp.y < my_MAPSIZE ) {
                            copy_grid( tripoint( gridx, gridy, gridz ),
                                       tripoint( gridx + sp.x, gridy + sp.y, gridz ) );
                            update_vehicle_list( get_submap_at_grid( { gridx, gridy, gridz } ), gridz );
                        } else {
                            loadn( tripoint( gridx, gridy, gridz ), true );
                        }
                    }
                } else { // sy < 0; work through it backwards
                    for( int gridy = my_MAPSIZE - 1; gridy >= 0; gridy-- ) {
                        if( gridx == my_MAPSIZE - 1 || gridy == my_MAPSIZE - 1 ) {
                            submaps_with_active_items.erase( { abs.x + gridx, abs.y + gridy, gridz } );
                        }
                        if( gridx + sp.x >= 0 && gridy + sp.y >= 0 ) {
                            copy_grid( tripoint( gridx, gridy, gridz ),
                                       tripoint( gridx + sp.x, gridy + sp.y, gridz ) );
                            update_vehicle_list( get_submap_at_grid( { gridx, gridy, gridz } ), gridz );
                        } else {
                            loadn( tripoint( gridx, gridy, gridz ), true );
                        }
                    }
                }
            }
        }
    }
    if( zlevels ) {
        //Go through the generated maps and fill in the roofs
        for( int gridz = zmin; gridz <= zmax; gridz++ ) {
            if( sp.x > 0 ) {
                for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
                    add_roofs( {my_MAPSIZE - 1, gridy, gridz} );
                }
            } else if( sp.x < 0 ) {
                for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
                    add_roofs( {0, gridy, gridz} );
                }
            }
 
            if( sp.y > 0 ) {
                for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
                    add_roofs( {gridx, my_MAPSIZE - 1, gridz} );
                }
            } else if( sp.y < 0 ) {
                for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
                    add_roofs( {gridx, 0, gridz} );
                }
            }
        }
    }
 
    reset_vehicle_cache( );
 
    g->setremoteveh( remoteveh );
 
    if( !support_cache_dirty.empty() ) {
        shift_tripoint_set( support_cache_dirty, shift_offset_pt, boundaries_2d );
    }
}

References add_roofs(), clear_vehicle_cache(), clear_vehicle_list(), copy_grid(), debugmsg, g, get_abs_sub(), get_cache(), get_submap_at_grid(), loadn(), MAPSIZE_X, MAPSIZE_Y, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, iuse::remoteveh(), reset_vehicle_cache(), SEEX, SEEY, set_abs_sub(), shift_bitset_cache< MAPSIZE, 1 >(), shift_bitset_cache< MAPSIZE_X, SEEX >(), shift_traps(), shift_tripoint_set(), submaps_with_active_items, support_cache_dirty, update_vehicle_list(), point::x, point::y, and zlevels.

Referenced by shift_traps(), and game::update_map().

◆ shift_traps()

void map::shift_traps ( const tripoint & shift )

protected

As part of the map shifting, this shifts the trap locations stored in traplocs.

Parameters

shift The amount shifting in submap, the same as go into shift.

Definition at line 6775 of file map.cpp.

{
    // Offset needs to have sign opposite to shift direction
    const tripoint offset( -shift.x * SEEX, -shift.y * SEEY, -shift.z );
    for( auto iter = field_furn_locs.begin(); iter != field_furn_locs.end(); ) {
        tripoint &pos = *iter;
        pos += offset;
        if( inbounds( pos ) ) {
            ++iter;
        } else {
            iter = field_furn_locs.erase( iter );
        }
    }
    for( auto &traps : traplocs ) {
        for( auto iter = traps.begin(); iter != traps.end(); ) {
            tripoint &pos = *iter;
            pos += offset;
            if( inbounds( pos ) ) {
                ++iter;
            } else {
                // Theoretical enhancement: if this is not the last entry of the vector,
                // move the last entry into pos and remove the last entry instead of iter.
                // This would avoid moving all the remaining entries.
                iter = traps.erase( iter );
            }
        }
    }
}

References field_furn_locs, inbounds(), SEEX, SEEY, shift(), and traplocs.

Referenced by shift().

◆ shift_vehicle_z()

void map::shift_vehicle_z	(	vehicle &	veh,
		int	z_shift
	)

Definition at line 6861 of file map.cpp.

{
 
    tripoint src = veh.global_pos3();
    tripoint dst = src + tripoint_above * z_shift;
 
    submap *src_submap = get_submap_at( src );
    submap *dst_submap = get_submap_at( dst );
 
    int our_i = -1;
    for( size_t i = 0; i < src_submap->vehicles.size(); i++ ) {
        if( src_submap->vehicles[i].get() == &veh ) {
            our_i = i;
            break;
        }
    }
 
    if( our_i == -1 ) {
        debugmsg( "shift_vehicle [%s] failed could not find vehicle", veh.name );
        return;
    }
 
    for( auto &prt : veh.get_all_parts() ) {
        prt.part().precalc[0].z -= z_shift;
    }
 
    veh.set_submap_moved( tripoint( dst.x / SEEX, dst.y / SEEY, dst.z ) );
    auto src_submap_veh_it = src_submap->vehicles.begin() + our_i;
    dst_submap->vehicles.push_back( std::move( *src_submap_veh_it ) );
    src_submap->vehicles.erase( src_submap_veh_it );
    dst_submap->is_uniform = false;
    invalidate_max_populated_zlev( dst.z );
 
    update_vehicle_list( dst_submap, dst.z );
 
    level_cache &ch = get_cache( src.z );
    for( const vehicle *elem : ch.vehicle_list ) {
        if( elem == &veh ) {
            ch.vehicle_list.erase( &veh );
            ch.zone_vehicles.erase( &veh );
            break;
        }
    }
 
}

References debugmsg, vehicle::get_all_parts(), get_cache(), get_submap_at(), vehicle::global_pos3(), invalidate_max_populated_zlev(), submap::is_uniform, avatar_action::move(), vehicle::name, SEEX, SEEY, vehicle::set_submap_moved(), tripoint_above, update_vehicle_list(), level_cache::vehicle_list, submap::vehicles, tripoint::x, tripoint::y, tripoint::z, and level_cache::zone_vehicles.

◆ shoot()

void map::shoot	(	const tripoint &	p,
		projectile &	proj,
		bool	hit_items
	)

Definition at line 3822 of file map.cpp.

{
    float initial_damage = 0.0;
    for( const damage_unit &dam : proj.impact ) {
        initial_damage += dam.amount * dam.damage_multiplier;
        initial_damage += dam.res_pen;
    }
    if( initial_damage < 0 ) {
        return;
    }
 
    float dam = initial_damage;
 
    if( has_flag( "ALARMED", p ) && !g->timed_events.queued( TIMED_EVENT_WANTED ) ) {
        sounds::sound( p, 30, sounds::sound_t::alarm, _( "an alarm sound!" ), true, "environment",
                       "alarm" );
        const tripoint abs = ms_to_sm_copy( getabs( p ) );
        g->timed_events.add( TIMED_EVENT_WANTED, calendar::turn + 30_minutes, 0, abs );
    }
 
    const bool inc = proj.has_effect( ammo_effect_INCENDIARY ) ||
                     proj.impact.type_damage( DT_HEAT ) > 0;
    if( const optional_vpart_position vp = veh_at( p ) ) {
        dam = vp->vehicle().damage( vp->part_index(), dam, inc ? DT_HEAT : DT_STAB, hit_items );
    }
 
    ter_id terrain = ter( p );
    ter_t ter = terrain.obj();
 
    if( ter.bash.ranged ) {
        const ranged_bash_info &ri = *ter.bash.ranged;
        if( !hit_items && !check( ri.block_unaimed_chance ) ) {
            // Nothing, it's a miss
        } else if( ri.reduction_laser && proj.has_effect( ammo_effect_LASER ) ) {
            dam -= rng( ri.reduction_laser->min, ri.reduction_laser->max );
        } else {
            dam -= rng( ri.reduction.min, ri.reduction.max );
            if( dam > ri.destroy_threshold ) {
                bash_params params{0, false, true, hit_items, 1.0, false};
                bash_ter_success( p, params );
            }
            if( dam <= 0 && is_transparent( p ) && get_avatar().sees( p ) ) {
                add_msg( _( "The shot is stopped by the %s!" ), tername( p ) );
            }
            if( ri.flammable && inc ) {
                add_field( p, fd_fire, 1 );
            }
        }
    } else if( impassable( p ) && !is_transparent( p ) ) {
        bash( p, dam, false );
        // TODO: Preserve some residual damage when it makes sense.
        dam = 0;
    }
 
    for( const ammo_effect_str_id &ae_id : proj.get_ammo_effects() ) {
        const ammo_effect &ae = *ae_id;
        if( ae.trail_field_type ) {
            if( x_in_y( ae.trail_chance, 100 ) ) {
                add_field( p, ae.trail_field_type, rng( ae.trail_intensity_min, ae.trail_intensity_max ) );
            }
        }
    }
 
    dam = std::max( 0.0f, dam );
 
    // Check fields?
    const field_entry *fieldhit = get_field( p, fd_web );
    if( fieldhit != nullptr ) {
        if( inc ) {
            add_field( p, fd_fire, fieldhit->get_field_intensity() - 1 );
        } else if( dam > 5 + fieldhit->get_field_intensity() * 5 &&
                   one_in( 5 - fieldhit->get_field_intensity() ) ) {
            dam -= rng( 1, 2 + fieldhit->get_field_intensity() * 2 );
            remove_field( p, fd_web );
        }
    }
 
    // Rescale the damage
    if( dam <= 0 ) {
        proj.impact.damage_units.clear();
        return;
    } else if( dam < initial_damage ) {
        proj.impact.mult_damage( dam / static_cast<double>( initial_damage ) );
    }
 
    //Projectiles with NO_ITEM_DAMAGE flag won't damage items at all
    if( !hit_items || !inbounds( p ) ) {
        return;
    }
 
    // Make sure the message is sensible for the ammo effects. Lasers aren't projectiles.
    std::string damage_message;
    if( proj.has_effect( ammo_effect_LASER ) ) {
        damage_message = _( "laser beam" );
    } else if( proj.has_effect( ammo_effect_LIGHTNING ) ) {
        damage_message = _( "bolt of electricity" );
    } else if( proj.has_effect( ammo_effect_PLASMA ) ) {
        damage_message = _( "bolt of plasma" );
    } else {
        damage_message = _( "flying projectile" );
    }
 
    smash_trap( p, dam, damage_message );
    smash_items( p, dam, damage_message, false );
}

References _, add_field(), add_msg(), sounds::alarm, ammo_effect_INCENDIARY, ammo_effect_LASER, ammo_effect_LIGHTNING, ammo_effect_PLASMA, damage_unit::amount, bash(), bash_ter_success(), ranged_bash_info::block_unaimed_chance, detail::check(), damage_unit::damage_multiplier, damage_instance::damage_units, ranged_bash_info::destroy_threshold, DT_HEAT, DT_STAB, fd_fire, fd_web, ranged_bash_info::flammable, g, projectile::get_ammo_effects(), get_avatar(), get_field(), field_entry::get_field_intensity(), getabs(), projectile::has_effect(), has_flag(), projectile::impact, impassable(), inbounds(), is_transparent(), ms_to_sm_copy(), damage_instance::mult_damage(), one_in(), ranged_bash_info::reduction, ranged_bash_info::reduction_laser, remove_field(), damage_unit::res_pen, rng(), sees(), smash_items(), smash_trap(), sounds::sound(), ter(), tername(), terrain, TIMED_EVENT_WANTED, ammo_effect::trail_chance, ammo_effect::trail_field_type, ammo_effect::trail_intensity_max, ammo_effect::trail_intensity_min, calendar::turn, damage_instance::type_damage(), veh_at(), and x_in_y().

◆ smash_items()

void map::smash_items	(	const tripoint &	p,
		int	power,
		const std::string &	cause_message,
		bool	do_destroy
	)

Tries to smash the items at the given tripoint.

Definition at line 3074 of file map.cpp.

{
    if( !has_items( p ) ) {
        return;
    }
 
    // Keep track of how many items have been damaged, and what the first one is
    int items_damaged = 0;
    int items_destroyed = 0;
    std::string damaged_item_name;
 
    // TODO: Bullets should be pretty much corpse-only
    constexpr const int min_destroy_threshold = 50;
 
    std::vector<item> contents;
    map_stack items = i_at( p );
    for( auto it = items.begin(); it != items.end(); ) {
        if( it->has_flag( "EXPLOSION_SMASHED" ) ) {
            it++;
            continue;
        }
 
        // detonate them if they can be exploded
        // We need to make a copy because the iterator validity is not predictable
        // see map_field.cpp process_fields_in_submap
        if( will_explode_on_impact( power ) && it->will_explode_in_fire() ) {
            item copy = *it;
            it = items.erase( it );
            if( copy.detonate( p, contents ) ) {
                // Need to restart, iterators may not be valid
                it = items.begin();
            }
            continue;
        }
 
        // If the power is low or it's not an explosion, only pulp rezing corpses
        if( ( power < min_destroy_threshold || !do_destroy ) && !it->can_revive() ) {
            it++;
            continue;
        }
 
        // Active explosives arbitrarily get double the destroy threshold
        bool is_active_explosive = it->active && it->type->get_use( "explosion" ) != nullptr;
        if( is_active_explosive && it->charges == 0 ) {
            it++;
            continue;
        }
 
        const float material_factor = it->chip_resistance( true );
        // Intact non-rezing get a boost
        const float intact_mult = 2.0f -
                                  ( static_cast<float>( it->damage_level( it->max_damage() ) ) / it->max_damage() );
        const float destroy_threshold = min_destroy_threshold
                                        + material_factor * intact_mult;
        // For pulping, only consider material resistance. Non-rezing can only be destroyed.
        const float pulp_threshold = it->can_revive() ? material_factor : destroy_threshold;
        // Active explosives that will explode this turn are indestructible (they are exploding "now")
        if( power < pulp_threshold ) {
            it++;
            continue;
        }
 
        bool item_was_destroyed = false;
        float destroy_chance = ( power - pulp_threshold ) / 4.0;
 
        const bool by_charges = it->count_by_charges();
        if( by_charges ) {
            destroy_chance *= it->charges_per_volume( 250_ml );
            if( x_in_y( destroy_chance, destroy_threshold ) ) {
                item_was_destroyed = true;
            }
        } else {
            const field_type_id type_blood = it->is_corpse() ? it->get_mtype()->bloodType() : fd_null;
            float roll = rng_float( 0.0, destroy_chance );
            if( roll >= destroy_threshold ) {
                item_was_destroyed = true;
            } else if( roll >= pulp_threshold ) {
                // Only pulp
                it->set_damage( it->max_damage() );
                // TODO: Blood streak cone away from explosion
                add_splash( type_blood, p, 1, destroy_chance );
                // If it was the first item to be damaged, note it
                if( items_damaged == 0 ) {
                    damaged_item_name = it->tname();
                }
                items_damaged++;
            }
        }
 
        // Remove them if they were damaged too much
        if( item_was_destroyed ) {
            // But save the contents, except for irremovable gunmods
            for( item *elem : it->contents.all_items_top() ) {
                if( !elem->is_irremovable() ) {
                    contents.push_back( item( *elem ) );
                }
            }
 
            if( items_damaged == 0 ) {
                damaged_item_name = it->tname();
            }
            it = i_rem( p, it );
            items_damaged++;
            items_destroyed++;
        } else {
            it++;
        }
    }
 
    // Let the player know that the item was damaged if they can see it.
    if( items_destroyed > 1 && g->u.sees( p ) ) {
        add_msg( m_bad, _( "The %s destroys several items!" ), cause_message );
    } else if( items_destroyed == 1 && items_damaged == 1 && g->u.sees( p ) )  {
        //~ %1$s: the cause of destruction, %2$s: destroyed item name
        add_msg( m_bad, _( "The %1$s destroys the %2$s!" ), cause_message, damaged_item_name );
    } else if( items_damaged > 1 && g->u.sees( p ) ) {
        add_msg( m_bad, _( "The %s damages several items." ), cause_message );
    } else if( items_damaged == 1 && g->u.sees( p ) )  {
        //~ %1$s: the cause of damage, %2$s: damaged item name
        add_msg( m_bad, _( "The %1$s damages the %2$s." ), cause_message, damaged_item_name );
    }
 
    for( const item &it : contents ) {
        add_item_or_charges( p, it );
    }
}

References _, add_item_or_charges(), add_msg(), add_splash(), item_contents::all_items_top(), item_stack::begin(), item::contents, item::detonate(), item_stack::end(), map_stack::erase(), fd_null, g, has_items(), i_at(), i_rem(), m_bad, rng_float(), will_explode_on_impact(), and x_in_y().

Referenced by move_vehicle(), and shoot().

◆ smash_trap()

void map::smash_trap	(	const tripoint &	p,
		const int	power,
		const std::string &	cause_message
	)

Tries to smash the trap at the given tripoint.

Definition at line 3054 of file map.cpp.

{
    const trap &tr = get_map().tr_at( p );
    if( tr.is_null() ) {
        return;
    }
 
    const bool is_explosive_trap = !tr.is_benign() && tr.vehicle_data.do_explosion;
 
    if( !will_explode_on_impact( power ) || !is_explosive_trap ) {
        return;
    }
    // make a fake NPC to trigger the trap
    npc dummy;
    dummy.set_fake( true );
    dummy.name = cause_message;
    dummy.setpos( p );
    tr.trigger( p, &dummy );
}

References vehicle_handle_trap_data::do_explosion, get_map(), trap::is_benign(), trap::is_null(), Character::name, Creature::set_fake(), npc::setpos(), tr_at(), trap::trigger(), trap::vehicle_data, and will_explode_on_impact().

Referenced by shoot().

◆ spawn_an_item() [1/2]

item & map::spawn_an_item	(	const tripoint &	p,
		item	new_item,
		int	charges,
		int	damlevel
	)

Definition at line 4265 of file map.cpp.

{
    if( charges && new_item.charges > 0 ) {
        //let's fail silently if we specify charges for an item that doesn't support it
        new_item.charges = charges;
    }
    new_item = new_item.in_its_container();
    if( ( new_item.made_of( LIQUID ) && has_flag( "SWIMMABLE", p ) ) ||
        has_flag( "DESTROY_ITEM", p ) ) {
        return null_item_reference();
    }
 
    new_item.set_damage( damlevel );
 
    return add_item_or_charges( p, new_item );
}

References add_item_or_charges(), item::charges, has_flag(), item::in_its_container(), LIQUID, item::made_of(), null_item_reference(), and item::set_damage().

Referenced by spawn_an_item(), and spawn_item().

◆ spawn_an_item() [2/2]

void map::spawn_an_item	(	point	p,
		item	new_item,
		int	charges,
		int	damlevel
	)

inline

Definition at line 1252 of file map.h.

                                                                                {
            spawn_an_item( tripoint( p, abs_sub.z ), new_item, charges, damlevel );
        }

References abs_sub, spawn_an_item(), and tripoint::z.

◆ spawn_artifact()

void map::spawn_artifact ( const tripoint & p )

Definition at line 4304 of file map.cpp.

{
    add_item_or_charges( p, item( new_artifact(), calendar::start_of_cataclysm ) );
}

References add_item_or_charges(), new_artifact(), and calendar::start_of_cataclysm.

Referenced by draw_mine(), and draw_temple().

◆ spawn_item() [1/4]

void map::spawn_item	(	const tripoint &	p,
		const itype_id &	type_id,
		unsigned	quantity = `1`,
		int	charges = `0`,
		const time_point &	birthday = `calendar::start_of_cataclysm`,
		int	damlevel = `0`
	)

Definition at line 4314 of file map.cpp.

{
    if( type_id.is_null() ) {
        return;
    }
 
    if( item_is_blacklisted( type_id ) ) {
        return;
    }
    // recurse to spawn (quantity - 1) items
    for( size_t i = 1; i < quantity; i++ ) {
        spawn_item( p, type_id, 1, charges, birthday, damlevel );
    }
    // spawn the item
    item new_item( type_id, birthday );
    if( one_in( 3 ) && new_item.has_flag( "VARSIZE" ) ) {
        new_item.set_flag( "FIT" );
    }
 
    spawn_an_item( p, new_item, charges, damlevel );
}

References item::has_flag(), string_id< T >::is_null(), item_is_blacklisted(), one_in(), item::set_flag(), spawn_an_item(), and spawn_item().

Referenced by jmapgen_spawn_item::apply(), MapExtras::burned_ground_parser(), talk_function::buy_100_logs(), talk_function::buy_10_logs(), create_burnproducts(), MapExtras::dead_vegetation_parser(), game::disable_robot(), draw_lab(), draw_mine(), draw_office_tower(), mapgen_cavern(), mapgen_tutorial(), MapExtras::mx_casings(), MapExtras::mx_drugdeal(), MapExtras::mx_grave(), MapExtras::mx_mayhem(), MapExtras::mx_minefield(), MapExtras::mx_roadworks(), om_cutdown_trees(), trap::on_disarmed(), mission_start::place_deposit_box(), MapExtras::place_fumarole(), mission_start::place_priest_diary(), place_vending(), mission_start::ranch_nurse_1(), mission_start::ranch_nurse_2(), mission_start::ranch_scavenger_1(), mission_start::ranch_scavenger_2(), mission_start::ranch_scavenger_3(), spawn_item(), and game::vertical_move().

◆ spawn_item() [2/4]

void map::spawn_item	(	const tripoint &	p,
		const std::string &	type_id,
		unsigned	quantity = `1`,
		int	charges = `0`,
		const time_point &	birthday = `calendar::start_of_cataclysm`,
		int	damlevel = `0`
	)

inline

Definition at line 1213 of file map.h.

                                                                                                     {
            spawn_item( p, itype_id( type_id ), quantity, charges, birthday, damlevel );
        }

References itype_id, and spawn_item().

◆ spawn_item() [3/4]

void map::spawn_item	(	point	p,
		const itype_id &	type_id,
		unsigned	quantity = `1`,
		int	charges = `0`,
		const time_point &	birthday = `calendar::start_of_cataclysm`,
		int	damlevel = `0`
	)

inline

Definition at line 1205 of file map.h.

                                                                                                     {
            spawn_item( tripoint( p, abs_sub.z ), type_id, quantity, charges, birthday, damlevel );
        }

References abs_sub, spawn_item(), and tripoint::z.

◆ spawn_item() [4/4]

void map::spawn_item	(	point	p,
		const std::string &	type_id,
		unsigned	quantity = `1`,
		int	charges = `0`,
		const time_point &	birthday = `calendar::start_of_cataclysm`,
		int	damlevel = `0`
	)

inline

Definition at line 1218 of file map.h.

                                                                                                     {
            spawn_item( tripoint( p, abs_sub.z ), type_id, quantity, charges, birthday, damlevel );
        }

References abs_sub, spawn_item(), and tripoint::z.

◆ spawn_items() [1/2]

std::vector< item * > map::spawn_items	(	const tripoint &	p,
		const std::vector< item > &	new_items
	)

Definition at line 4283 of file map.cpp.

{
    std::vector<item *> ret;
    if( !inbounds( p ) || has_flag( "DESTROY_ITEM", p ) ) {
        return ret;
    }
    const bool swimmable = has_flag( "SWIMMABLE", p );
    for( const item &new_item : new_items ) {
 
        if( new_item.made_of( LIQUID ) && swimmable ) {
            continue;
        }
        item &it = add_item_or_charges( p, new_item );
        if( !it.is_null() ) {
            ret.push_back( &it );
        }
    }
 
    return ret;
}

References add_item_or_charges(), has_flag(), inbounds(), item::is_null(), LIQUID, and cata::hash64_detail::ret.

Referenced by jmapgen_loot::apply(), bash_furn_success(), bash_items(), bash_ter_success(), talk_function::loot_building(), MapExtras::mx_casings(), MapExtras::mx_corpses(), process_fields_in_submap(), put_items_from_loc(), veh_utils::repair_part(), and spawn_items().

◆ spawn_items() [2/2]

void map::spawn_items	(	point	p,
		const std::vector< item > &	new_items
	)

inline

Definition at line 1328 of file map.h.

                                                                      {
            spawn_items( tripoint( p, abs_sub.z ), new_items );
        }

References abs_sub, spawn_items(), and tripoint::z.

◆ spawn_monsters()

void map::spawn_monsters ( bool ignore_sight )

Spawn monsters from submap spawn points and from the overmap.

Parameters

ignore_sight If true, monsters may spawn in the view of the player character (useful when the whole map has been loaded instead, e.g. when starting a new game, or after teleportation or after moving vertically). If false, monsters are not spawned in view of player character.

Definition at line 7847 of file map.cpp.

{
    const int zmin = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    const int zmax = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    tripoint gp;
    int &gx = gp.x;
    int &gy = gp.y;
    int &gz = gp.z;
    for( gz = zmin; gz <= zmax; gz++ ) {
        for( gx = 0; gx < my_MAPSIZE; gx++ ) {
            for( gy = 0; gy < my_MAPSIZE; gy++ ) {
                spawn_monsters_submap( gp, ignore_sight );
            }
        }
    }
}

References abs_sub, my_MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, spawn_monsters_submap(), tripoint::x, tripoint::y, tripoint::z, and zlevels.

Referenced by game::do_turn(), game::place_player_overmap(), game::start_game(), game::update_map(), and game::vertical_shift().

◆ spawn_monsters_submap()

void map::spawn_monsters_submap	(	const tripoint &	gp,
		bool	ignore_sight
	)

private

Definition at line 7792 of file map.cpp.

{
    // Load unloaded monsters
    // TODO: fix point types
    overmap_buffer.spawn_monster( tripoint_abs_sm( gp + abs_sub.xy() ) );
 
    // Only spawn new monsters after existing monsters are loaded.
    // TODO: fix point types
    auto groups = overmap_buffer.groups_at( tripoint_abs_sm( gp + abs_sub.xy() ) );
    for( auto &mgp : groups ) {
        spawn_monsters_submap_group( gp, *mgp, ignore_sight );
    }
 
    submap *const current_submap = get_submap_at_grid( gp );
    const tripoint gp_ms = sm_to_ms_copy( gp );
 
    for( auto &i : current_submap->spawns ) {
        const tripoint center = gp_ms + i.pos;
        const tripoint_range<tripoint> points = points_in_radius( center, 3 );
 
        for( int j = 0; j < i.count; j++ ) {
            monster tmp( i.type );
            tmp.mission_id = i.mission_id;
            if( i.name != "NONE" ) {
                tmp.unique_name = i.name;
            }
            if( i.friendly ) {
                tmp.friendly = -1;
            }
 
            const auto valid_location = [&]( const tripoint & p ) {
                // Checking for creatures via g is only meaningful if this is the main game map.
                // If it's some local map instance, the coordinates will most likely not even match.
                return ( !g || &get_map() != this || !g->critter_at( p ) ) && tmp.can_move_to( p );
            };
 
            const auto place_it = [&]( const tripoint & p ) {
                monster *const placed = g->place_critter_at( make_shared_fast<monster>( tmp ), p );
                if( placed ) {
                    placed->on_load();
                }
            };
 
            // First check out defined spawn location for a valid placement, and if that doesn't work
            // then fall back to picking a random point that is a valid location.
            if( valid_location( center ) ) {
                place_it( center );
            } else if( const std::optional<tripoint> pos = random_point( points, valid_location ) ) {
                place_it( *pos );
            }
        }
    }
    current_submap->spawns.clear();
}

References abs_sub, monster::can_move_to(), center, monster::friendly, g, get_map(), get_submap_at_grid(), overmapbuffer::groups_at(), monster::mission_id, monster::on_load(), overmap_buffer, points_in_radius(), random_point(), sm_to_ms_copy(), overmapbuffer::spawn_monster(), spawn_monsters_submap_group(), submap::spawns, monster::unique_name, and tripoint::xy().

Referenced by spawn_monsters().

◆ spawn_monsters_submap_group()

void map::spawn_monsters_submap_group	(	const tripoint &	gp,
		mongroup &	group,
		bool	ignore_sight
	)

private

Definition at line 7658 of file map.cpp.

{
    const int s_range = std::min( HALF_MAPSIZE_X,
                                  g->u.sight_range( g->light_level( g->u.posz() ) ) );
    int pop = group.population;
    std::vector<tripoint> locations;
    if( !ignore_sight ) {
        // If the submap is one of the outermost submaps, assume that monsters are
        // invisible there.
        if( gp.x == 0 || gp.y == 0 || gp.x + 1 == MAPSIZE || gp.y + 1 == MAPSIZE ) {
            ignore_sight = true;
        }
    }
 
    if( gp.z != g->u.posz() ) {
        // Note: this is only OK because 3D vision isn't a thing yet
        ignore_sight = true;
    }
 
    static const auto allow_on_terrain = [&]( const tripoint & p ) {
        // TODO: flying creatures should be allowed to spawn without a floor,
        // but the new creature is created *after* determining the terrain, so
        // we can't check for it here.
        return passable( p ) && has_floor( p );
    };
 
    // If the submap is uniform, we can skip many checks
    const submap *current_submap = get_submap_at_grid( gp );
    bool ignore_terrain_checks = false;
    bool ignore_inside_checks = gp.z < 0;
    if( current_submap->is_uniform ) {
        const tripoint upper_left{ SEEX * gp.x, SEEY * gp.y, gp.z };
        if( !allow_on_terrain( upper_left ) ||
            ( !ignore_inside_checks && has_flag_ter_or_furn( TFLAG_INDOORS, upper_left ) ) ) {
            const tripoint glp = getabs( gp );
            dbg( DL::Warn ) << "Empty locations for group " << group.type.str()
                            << " at uniform submap " << gp << " global " << glp;
            return;
        }
 
        ignore_terrain_checks = true;
        ignore_inside_checks = true;
    }
 
    for( int x = 0; x < SEEX; ++x ) {
        for( int y = 0; y < SEEY; ++y ) {
            int fx = x + SEEX * gp.x;
            int fy = y + SEEY * gp.y;
            tripoint fp{ fx, fy, gp.z };
            if( g->critter_at( fp ) != nullptr ) {
                continue; // there is already some creature
            }
 
            if( !ignore_terrain_checks && !allow_on_terrain( fp ) ) {
                continue; // solid area, impassable
            }
 
            if( !ignore_sight && sees( g->u.pos(), fp, s_range ) ) {
                continue; // monster must spawn outside the viewing range of the player
            }
 
            if( !ignore_inside_checks && has_flag_ter_or_furn( TFLAG_INDOORS, fp ) ) {
                continue; // monster must spawn outside.
            }
 
            locations.push_back( fp );
        }
    }
 
    if( locations.empty() ) {
        // TODO: what now? there is no possible place to spawn monsters, most
        // likely because the player can see all the places.
        const tripoint glp = getabs( gp );
        dbg( DL::Warn ) << "Empty locations for group " << group.type.str()
                        << " at " << gp << " global " << glp;
        // Just kill the group. It's not like we're removing existing monsters
        // Unless it's a horde - then don't kill it and let it spawn behind a tree or smoke cloud
        if( !group.horde ) {
            group.clear();
        }
 
        return;
    }
 
    if( pop ) {
        // Populate the group from its population variable.
        for( int m = 0; m < pop; m++ ) {
            MonsterGroupResult spawn_details = MonsterGroupManager::GetResultFromGroup( group.type, &pop );
            if( !spawn_details.name ) {
                continue;
            }
            monster tmp( spawn_details.name );
 
            // If a monster came from a horde population, configure them to always be willing to rejoin a horde.
            if( group.horde ) {
                tmp.set_horde_attraction( MHA_ALWAYS );
            }
            for( int i = 0; i < spawn_details.pack_size; i++ ) {
                group.monsters.push_back( tmp );
            }
        }
    }
 
    // Find horde's target submap
    // TODO: fix point types
    tripoint horde_target( tripoint( -abs_sub.xy(), abs_sub.z ) + group.target.xy().raw() );
    sm_to_ms( horde_target );
    for( auto &tmp : group.monsters ) {
        for( int tries = 0; tries < 10 && !locations.empty(); tries++ ) {
            const tripoint p = random_entry_removed( locations );
            if( !tmp.can_move_to( p ) ) {
                continue; // target can not contain the monster
            }
            if( group.horde ) {
                // Give monster a random point near horde's expected destination
                const tripoint rand_dest = horde_target +
                                           point( rng( 0, SEEX ), rng( 0, SEEY ) );
                const int turns = rl_dist( p, rand_dest ) + group.interest;
                tmp.wander_to( rand_dest, turns );
                add_msg( m_debug, "%s targeting %d,%d,%d", tmp.disp_name(),
                         tmp.wander_pos.x, tmp.wander_pos.y, tmp.wander_pos.z );
            }
 
            monster *const placed = g->place_critter_at( make_shared_fast<monster>( tmp ), p );
            if( placed ) {
                placed->on_load();
            }
            break;
        }
    }
    // indicates the group is empty, and can be removed later
    group.clear();
}

References abs_sub, add_msg(), dbg, g, get_submap_at_grid(), getabs(), MonsterGroupManager::GetResultFromGroup(), HALF_MAPSIZE_X, has_flag_ter_or_furn(), has_floor(), submap::is_uniform, anonymous_namespace{overmap_location.cpp}::locations, m_debug, MAPSIZE, MHA_ALWAYS, MonsterGroupResult::name, monster::on_load(), MonsterGroupResult::pack_size, passable(), random_entry_removed(), rl_dist(), rng(), sees(), SEEX, SEEY, monster::set_horde_attraction(), sm_to_ms(), TFLAG_INDOORS, Warn, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by spawn_monsters_submap().

◆ spawn_natural_artifact()

void map::spawn_natural_artifact	(	const tripoint &	p,
		artifact_natural_property	prop
	)

Definition at line 4309 of file map.cpp.

{
    add_item_or_charges( p, item( new_natural_artifact( prop ), calendar::start_of_cataclysm ) );
}

References add_item_or_charges(), new_natural_artifact(), and calendar::start_of_cataclysm.

Referenced by debug_menu::debug(), and MapExtras::mx_portal_in().

◆ spread_gas()

void map::spread_gas	(	field_entry &	cur,
		const tripoint &	p,
		int	percent_spread,
		const time_duration &	outdoor_age_speedup,
		scent_block &	sblk
	)

private

Definition at line 252 of file map_field.cpp.

{
    map &here = get_map();
    // TODO: fix point types
    const oter_id &cur_om_ter =
        overmap_buffer.ter( tripoint_abs_omt( ms_to_omt_copy( here.getabs( p ) ) ) );
    const bool sheltered = g->is_sheltered( p );
    const weather_manager &weather = get_weather();
    const int winddirection = weather.winddirection;
    const int windpower = get_local_windpower( weather.windspeed, cur_om_ter, p, winddirection,
                          sheltered );
 
    const int current_intensity = cur.get_field_intensity();
    const field_type_id ft_id = cur.get_field_type();
 
    const int scent_neutralize = ft_id->get_intensity_level( current_intensity -
                                 1 ).scent_neutralization;
 
    if( scent_neutralize > 0 ) {
        // modify scents by neutralization value (minus)
        for( const tripoint &tmp : points_in_radius( p, 1 ) ) {
            sblk.apply_gas( tmp, scent_neutralize );
        }
    }
 
    // Dissipate faster outdoors.
    if( is_outside( p ) ) {
        const time_duration current_age = cur.get_field_age();
        cur.set_field_age( current_age + outdoor_age_speedup );
    }
 
    // Bail out if we don't meet the spread chance or required intensity.
    if( current_intensity <= 1 || rng( 1, 100 - windpower ) > percent_spread ) {
        return;
    }
 
    // First check if we can fall
    // TODO: Make fall and rise chances parameters to enable heavy/light gas
    if( zlevels && p.z > -OVERMAP_DEPTH ) {
        const tripoint down{ p.xy(), p.z - 1 };
        if( gas_can_spread_to( cur, p, down ) && valid_move( p, down, true, true ) ) {
            maptile down_tile = maptile_at_internal( down );
            gas_spread_to( cur, down_tile, down );
            return;
        }
    }
 
    auto neighs = get_neighbors( p );
    size_t end_it = static_cast<size_t>( rng( 0, neighs.size() - 1 ) );
    std::vector<size_t> spread;
    std::vector<size_t> neighbour_vec;
    // Then, spread to a nearby point.
    // If not possible (or randomly), try to spread up
    // Wind direction will block the field spreading into the wind.
    // Start at end_it + 1, then wrap around until all elements have been processed.
    for( size_t i = ( end_it + 1 ) % neighs.size(), count = 0;
         count != neighs.size();
         i = ( i + 1 ) % neighs.size(), count++ ) {
        const auto &neigh = neighs[i];
        if( gas_can_spread_to( cur, p, neigh.first ) ) {
            spread.push_back( i );
        }
    }
    auto maptiles = get_wind_blockers( winddirection, p );
    // Three map tiles that are facing the wind direction.
    const maptile remove_tile = std::get<0>( maptiles );
    const maptile remove_tile2 = std::get<1>( maptiles );
    const maptile remove_tile3 = std::get<2>( maptiles );
    if( !spread.empty() && ( !zlevels || one_in( spread.size() ) ) ) {
        // Construct the destination from offset and p
        if( g->is_sheltered( p ) || windpower < 5 ) {
            std::pair<tripoint, maptile> &n = neighs[ random_entry( spread ) ];
            gas_spread_to( cur, n.second, n.first );
        } else {
            end_it = static_cast<size_t>( rng( 0, neighs.size() - 1 ) );
            // Start at end_it + 1, then wrap around until all elements have been processed.
            for( size_t i = ( end_it + 1 ) % neighs.size(), count = 0;
                 count != neighs.size();
                 i = ( i + 1 ) % neighs.size(), count++ ) {
                const auto &neigh = neighs[i].second;
                if( ( neigh.pos_.x != remove_tile.pos_.x && neigh.pos_.y != remove_tile.pos_.y ) ||
                    ( neigh.pos_.x != remove_tile2.pos_.x && neigh.pos_.y != remove_tile2.pos_.y ) ||
                    ( neigh.pos_.x != remove_tile3.pos_.x && neigh.pos_.y != remove_tile3.pos_.y ) ) {
                    neighbour_vec.push_back( i );
                } else if( x_in_y( 1, std::max( 2, windpower ) ) ) {
                    neighbour_vec.push_back( i );
                }
            }
            if( !neighbour_vec.empty() ) {
                std::pair<tripoint, maptile> &n = neighs[neighbour_vec[rng( 0, neighbour_vec.size() - 1 )]];
                gas_spread_to( cur, n.second, n.first );
            }
        }
    } else if( zlevels && p.z < OVERMAP_HEIGHT ) {
        const tripoint up{ p.xy(), p.z + 1 };
        if( gas_can_spread_to( cur, p, up ) && valid_move( p, up, true, true ) ) {
            maptile up_tile = maptile_at_internal( up );
            gas_spread_to( cur, up_tile, up );
        }
    }
}

References scent_block::apply_gas(), detail::count(), g, gas_can_spread_to(), gas_spread_to(), field_entry::get_field_age(), field_entry::get_field_intensity(), field_entry::get_field_type(), field_type::get_intensity_level(), get_local_windpower(), get_map(), get_neighbors(), get_weather(), get_wind_blockers(), anonymous_namespace{iexamine_elevator.cpp}::elevator::here(), is_outside(), maptile_at_internal(), ms_to_omt_copy(), one_in(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, points_in_radius(), maptile::pos_, random_entry(), rng(), field_intensity_level::scent_neutralization, field_entry::set_field_age(), overmapbuffer::ter(), valid_move(), point::x, x_in_y(), tripoint::xy(), point::y, tripoint::z, and zlevels.

Referenced by process_fields_in_submap().

◆ stored_volume()

units::volume map::stored_volume ( const tripoint & p )

Definition at line 4344 of file map.cpp.

{
    return i_at( p ).stored_volume();
}

References i_at(), and item_stack::stored_volume().

◆ support_dirty()

void map::support_dirty ( const tripoint & p )

private

Definition at line 2349 of file map.cpp.

{
    if( zlevels ) {
        support_cache_dirty.insert( p );
    }
}

References support_cache_dirty, and zlevels.

Referenced by add_field(), add_item_or_charges(), drop_furniture(), furn_set(), ter_set(), and update_suspension_cache().

◆ supports_above()

bool map::supports_above ( const tripoint & p ) const

Does this tile support vehicles and furniture above it.

Definition at line 2102 of file map.cpp.

{
    const maptile tile = maptile_at( p );
    const ter_t &ter = tile.get_ter_t();
    if( ter.movecost == 0 ) {
        return true;
    }
 
    const furn_id frn_id = tile.get_furn();
    if( frn_id != f_null ) {
        const furn_t &frn = frn_id.obj();
        if( frn.movecost < 0 ) {
            return true;
        }
    }
 
    return veh_at( p ).has_value();
}

References f_null, maptile::get_furn(), maptile::get_ter_t(), maptile_at(), map_data_common_t::movecost, int_id< T >::obj(), ter(), and veh_at().

Referenced by drop_furniture().

◆ ter() [1/2]

ter_id map::ter ( const tripoint & p ) const

Definition at line 1563 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return t_null;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    return current_submap->get_ter( l );
}

References get_submap_at(), submap::get_ter(), inbounds(), and t_null.

Referenced by actualize(), ter_furn_transform::add_all_messages(), add_boardable(), cata_event_dispatch::avatar_moves(), bash_rating(), bash_resistance(), bash_strength(), bash_ter_furn(), bash_ter_success(), board_up(), MapExtras::burned_ground_parser(), close_door(), coverage(), MapExtras::dead_vegetation_parser(), determine_wall_corner(), displace_water(), construct::done_digormine_stair(), construct::done_mine_upstair(), draw_connections(), draw_lab(), editmap::draw_main_ui_overlay(), draw_mine(), draw_temple(), draw_triffid(), examine(), game::examine(), game::extended_description(), feature< ter_id >(), talk_function::field_plant(), game::find_or_make_stairs(), find_potential_computer_point(), gas_can_spread_to(), get_changed_ids_from_update(), get_harvest(), get_harvest_names(), get_known_connections(), get_roof(), get_ter_transforms_into(), has_flag_ter(), hit_with_acid(), advanced_inv_area::init(), is_bashable(), is_bashable_ter(), anonymous_namespace{gates.cpp}::gate_data::is_suitable_wall(), is_suspension_valid(), talk_function::loot_building(), mapgen_ants_generic(), mapgen_lake_shore(), fungal_effects::marlossify(), map_stack::max_volume(), map_funcs::migo_nerve_cage_removal(), avatar_action::move(), move_cost(), move_vehicle(), MapExtras::mx_crater(), MapExtras::mx_grove(), MapExtras::mx_helicopter(), MapExtras::mx_house_spider(), MapExtras::mx_house_wasp(), MapExtras::mx_portal_in(), MapExtras::mx_shrubbery(), obstacle_coverage(), om_cutdown_trees(), om_harvest_ter(), open_door(), mission_start::place_deposit_box(), place_items(), game::place_player(), game::print_fields_info(), game::print_graffiti_info(), process_fields_in_submap(), produce_sap(), rad_scorch(), resolve_regional_terrain_and_furniture(), restock_fruits(), mission_start::reveal_lab_train_depot(), shoot(), supports_above(), temperature_flag_at_point(), rot::temperature_flag_for_location(), ter(), tername(), ter_furn_transform::transform(), translate(), translate_radius(), trap_set(), Character::update_bodytemp(), update_suspension_cache(), vehicle_wheel_traction(), game::vertical_move(), game::walk_move(), and water_from().

◆ ter() [2/2]

ter_id map::ter ( point p ) const

inline

Definition at line 816 of file map.h.

                                    {
            return ter( tripoint( p, abs_sub.z ) );
        }

References abs_sub, ter(), and tripoint::z.

◆ ter_set() [1/2]

bool map::ter_set	(	const tripoint &	p,
		const ter_id &	new_terrain
	)

Definition at line 1704 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return false;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
    const ter_id old_id = current_submap->get_ter( l );
    if( old_id == new_terrain ) {
        // Nothing changed
        return false;
    }
 
    current_submap->set_ter( l, new_terrain );
 
    // Set the dirty flags
    const ter_t &old_t = old_id.obj();
    const ter_t &new_t = new_terrain.obj();
 
    // HACK: Hack around ledges in traplocs or else it gets NASTY in z-level mode
    if( old_t.trap != tr_null && old_t.trap != tr_ledge ) {
        auto &traps = traplocs[old_t.trap.to_i()];
        const auto iter = std::find( traps.begin(), traps.end(), p );
        if( iter != traps.end() ) {
            traps.erase( iter );
        }
    }
    if( new_t.trap != tr_null && new_t.trap != tr_ledge ) {
        traplocs[new_t.trap.to_i()].push_back( p );
    }
 
    if( old_t.transparent != new_t.transparent ) {
        set_transparency_cache_dirty( p );
        set_seen_cache_dirty( p );
    }
 
    if( old_t.has_flag( TFLAG_INDOORS ) != new_t.has_flag( TFLAG_INDOORS ) ) {
        set_outside_cache_dirty( p.z );
    }
 
    if( new_t.has_flag( TFLAG_NO_FLOOR ) != old_t.has_flag( TFLAG_NO_FLOOR ) ) {
        set_floor_cache_dirty( p.z );
        // It's a set, not a flag
        support_cache_dirty.insert( p );
        set_seen_cache_dirty( p );
    }
 
    if( new_t.has_flag( TFLAG_SUSPENDED ) != old_t.has_flag( TFLAG_SUSPENDED ) ) {
        set_suspension_cache_dirty( p.z );
        if( new_t.has_flag( TFLAG_SUSPENDED ) ) {
            level_cache &ch = get_cache( p.z );
            ch.suspension_cache.emplace_back( getabs( p ).xy() );
        }
    }
 
    invalidate_max_populated_zlev( p.z );
 
    set_memory_seen_cache_dirty( p );
 
    // TODO: Limit to changes that affect move cost, traps and stairs
    set_pathfinding_cache_dirty( p.z );
 
    tripoint above( p.xy(), p.z + 1 );
    // Make sure that if we supported something and no longer do so, it falls down
    support_dirty( above );
 
    return true;
}

References detail::find(), get_cache(), get_submap_at(), submap::get_ter(), getabs(), map_data_common_t::has_flag(), inbounds(), invalidate_max_populated_zlev(), int_id< T >::obj(), set_floor_cache_dirty(), set_memory_seen_cache_dirty(), set_outside_cache_dirty(), set_pathfinding_cache_dirty(), set_seen_cache_dirty(), set_suspension_cache_dirty(), submap::set_ter(), set_transparency_cache_dirty(), support_cache_dirty, support_dirty(), level_cache::suspension_cache, TFLAG_INDOORS, TFLAG_NO_FLOOR, TFLAG_SUSPENDED, int_id< T >::to_i(), tr_ledge, tr_null, map_data_common_t::transparent, ter_t::trap, traplocs, tripoint::xy(), and tripoint::z.

Referenced by add_computer(), jmapgen_terrain::apply(), jmapgen_computer::apply(), jmapgen_setmap::apply(), bash_ter_success(), board_up(), MapExtras::burned_ground_parser(), iexamine::cardreader_robofac(), close_door(), collapse_at(), collapse_invalid_suspension(), MapExtras::dead_vegetation_parser(), displace_water(), construct::done_digormine_stair(), construct::done_mine_upstair(), construct::done_ramp_high(), construct::done_ramp_low(), construct::done_wood_stairs(), draw_anthill(), draw_circle_ter(), draw_connections(), draw_lab(), draw_line_ter(), draw_mine(), draw_rough_circle_ter(), draw_slimepit(), draw_square_ter(), draw_temple(), draw_triffid(), farm_action(), talk_function::field_harvest(), game::forced_door_closing(), mapgen_function_json_base::formatted_set_incredibly_simple(), mapf::formatted_set_simple(), hit_with_acid(), talk_function::loot_building(), make_rubble(), mapgen_ants_curved(), mapgen_ants_four_way(), mapgen_ants_generic(), mapgen_ants_straight(), mapgen_ants_tee(), mapgen_cavern(), mapgen_crater(), mapgen_field(), mapgen_forest_trail_curved(), mapgen_forest_trail_four_way(), mapgen_forest_trail_straight(), mapgen_forest_trail_tee(), mapgen_hellmouth(), mapgen_highway(), mapgen_hive(), mapgen_lake_shore(), mapgen_null(), mapgen_parking_lot(), mapgen_rift(), mapgen_river_curved(), mapgen_river_curved_not(), mapgen_river_straight(), mapgen_road(), mapgen_rock_partial(), mapgen_sewer_curved(), mapgen_sewer_four_way(), mapgen_sewer_straight(), mapgen_sewer_tee(), mapgen_test(), mapgen_tutorial(), fungal_effects::marlossify(), map_funcs::migo_nerve_cage_removal(), move_vehicle(), MapExtras::mx_bandits_block(), MapExtras::mx_clay_deposit(), MapExtras::mx_clearcut(), MapExtras::mx_crater(), MapExtras::mx_grave(), MapExtras::mx_grove(), MapExtras::mx_helicopter(), MapExtras::mx_house_wasp(), MapExtras::mx_pond(), MapExtras::mx_portal_in(), MapExtras::mx_roadblock(), MapExtras::mx_shrubbery(), MapExtras::mx_spider(), om_cutdown_trees(), om_harvest_ter(), om_set_hide_site(), open_door(), MapExtras::place_fumarole(), place_gas_pump(), mission_start::place_npc_software(), process_fields_in_submap(), rad_scorch(), mission_start::ranch_nurse_4(), mission_start::ranch_nurse_5(), mission_start::ranch_scavenger_2(), mission_start::ranch_scavenger_3(), resolve_regional_terrain_and_furniture(), restock_fruits(), science_room(), set(), fungal_effects::spread_fungus_one_tile(), ter_or_furn_set(), ter_set(), ter_furn_transform::transform(), translate(), translate_radius(), and game::vertical_move().

◆ ter_set() [2/2]

bool map::ter_set	(	point	p,
		const ter_id &	new_terrain
	)

inline

Definition at line 841 of file map.h.

                                                           {
            return ter_set( tripoint( p, abs_sub.z ), new_terrain );
        }

References abs_sub, ter_set(), and tripoint::z.

◆ tername() [1/2]

std::string map::tername ( const tripoint & p ) const

Definition at line 1774 of file map.cpp.

{
    return ter( p ).obj().name();
}

References map_data_common_t::name(), int_id< T >::obj(), and ter().

Referenced by game::grabbed_furn_move(), game::monmove(), name(), game::place_player(), shoot(), avatar_action::swim(), tername(), game::update_stair_monsters(), and game::vertical_move().

◆ tername() [2/2]

std::string map::tername ( point p ) const

inline

Definition at line 846 of file map.h.

                                           {
            return tername( tripoint( p, abs_sub.z ) );
        }

References abs_sub, tername(), and tripoint::z.

◆ tinder_at()

bool map::tinder_at ( const tripoint & p )

Checks if there are any tinder flagged items on the tile.

Parameters

p	tile to check

Definition at line 2678 of file map.cpp.

{
    for( const auto &i : i_at( p ) ) {
        if( i.has_flag( "TINDER" ) ) {
            return true;
        }
    }
    return false;
}

References i_at().

◆ tr_at()

const trap & map::tr_at ( const tripoint & p ) const

Definition at line 5258 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return tr_null.obj();
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
 
    if( current_submap->get_ter( l ).obj().trap != tr_null ) {
        return current_submap->get_ter( l ).obj().trap.obj();
    }
 
    return current_submap->get_trap( l ).obj();
}

References get_submap_at(), submap::get_ter(), submap::get_trap(), inbounds(), int_id< T >::obj(), tr_null, and ter_t::trap.

Referenced by can_see_trap_at(), construct::check_no_trap(), creature_on_trap(), disarm_trap(), draw_lab(), editmap::draw_main_ui_overlay(), game::examine(), feature< trap_id >(), fill_funnels(), game::fling_creature(), game::get_dangerous_tile(), game::grabbed_furn_move(), MapExtras::mx_minefield(), MapExtras::mx_portal(), game::print_trap_info(), game::process_artifact(), game::prompt_dangerous_tile(), smash_trap(), and valid_move().

◆ translate()

void map::translate	(	const ter_id &	from,
		const ter_id &	to
	)

Definition at line 4053 of file map.cpp.

{
    if( from == to ) {
        debugmsg( "map::translate %s => %s",
                  from.obj().name(),
                  from.obj().name() );
        return;
    }
    for( const tripoint &p : points_on_zlevel() ) {
        if( ter( p ) == from ) {
            ter_set( p, to );
        }
    }
}

References debugmsg, map_data_common_t::name(), int_id< T >::obj(), points_on_zlevel(), ter(), and ter_set().

Referenced by jmapgen_translate::apply(), mapgen_lake_shore(), start_location::prepare_map(), mission_start::ranch_nurse_5(), mission_start::ranch_nurse_6(), mission_start::ranch_nurse_7(), mission_start::ranch_nurse_8(), and mission_start::ranch_scavenger_3().

◆ translate_radius()

void map::translate_radius	(	const ter_id &	from,
		const ter_id &	to,
		float	radi,
		const tripoint &	p,
		bool	same_submap = `false`,
		bool	toggle_between = `false`
	)

Definition at line 4069 of file map.cpp.

{
    if( from == to ) {
        debugmsg( "map::translate %s => %s", from.obj().name(), to.obj().name() );
        return;
    }
 
    const tripoint abs_omt_p = ms_to_omt_copy( getabs( p ) );
    for( const tripoint &t : points_on_zlevel() ) {
        const tripoint abs_omt_t = ms_to_omt_copy( getabs( t ) );
        const float radiX = trig_dist( p, t );
        if( ter( t ) == from ) {
            // within distance, and either no submap limitation or same overmap coords.
            if( radiX <= radi && ( !same_submap || abs_omt_t == abs_omt_p ) ) {
                ter_set( t, to );
            }
        } else if( toggle_between && ter( t ) == to ) {
            if( radiX <= radi && ( !same_submap || abs_omt_t == abs_omt_p ) ) {
                ter_set( t, from );
            }
        }
    }
}

References debugmsg, getabs(), ms_to_omt_copy(), map_data_common_t::name(), int_id< T >::obj(), points_on_zlevel(), ter(), ter_set(), and trig_dist().

Referenced by computer_session::action_lock(), computer_session::action_open(), computer_session::action_release(), computer_session::action_release_bionics(), computer_session::action_shutters(), and computer_session::action_unlock().

◆ trap_locations()

const std::vector< tripoint > & map::trap_locations ( const trap_id & type ) const

Definition at line 7893 of file map.cpp.

{
    return traplocs[type.to_i()];
}

References traplocs, and type.

◆ trap_set()

void map::trap_set	(	const tripoint &	p,
		const trap_id &	type
	)

Definition at line 5310 of file map.cpp.

{
    if( !inbounds( p ) ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( p, l );
    const ter_t &ter = current_submap->get_ter( l ).obj();
    if( ter.trap != tr_null ) {
        debugmsg( "set trap %s on top of terrain %s which already has a builit-in trap",
                  type.obj().name(), ter.name() );
        return;
    }
 
    // If there was already a trap here, remove it.
    if( current_submap->get_trap( l ) != tr_null ) {
        remove_trap( p );
    }
 
    current_submap->set_trap( l, type );
    if( type != tr_null ) {
        traplocs[type.to_i()].push_back( p );
    }
}

References debugmsg, get_submap_at(), submap::get_ter(), submap::get_trap(), inbounds(), int_id< T >::obj(), remove_trap(), submap::set_trap(), ter(), tr_null, traplocs, and type.

Referenced by jmapgen_trap::apply(), construct::done_mark_firewood(), construct::done_mark_practice_target(), draw_lab(), mtrap_set(), and MapExtras::mx_portal().

◆ unboard_vehicle() [1/2]

void map::unboard_vehicle	(	const tripoint &	p,
		bool	dead_passenger = `false`
	)

Definition at line 1166 of file map.cpp.

{
    const std::optional<vpart_reference> vp = veh_at( p ).part_with_feature( VPFLAG_BOARDABLE, false );
    player *passenger = nullptr;
    if( !vp ) {
        debugmsg( "map::unboard_vehicle: vehicle not found" );
        // Try and force unboard the player anyway.
        passenger = g->critter_at<player>( p );
        if( passenger ) {
            passenger->in_vehicle = false;
            passenger->controlling_vehicle = false;
        }
        return;
    }
    passenger = vp->get_passenger();
    unboard_vehicle( *vp, passenger, dead_passenger );
}

References Character::controlling_vehicle, debugmsg, g, Character::in_vehicle, optional_vpart_position::part_with_feature(), unboard_vehicle(), veh_at(), and VPFLAG_BOARDABLE.

◆ unboard_vehicle() [2/2]

void map::unboard_vehicle	(	const vpart_reference &	vp,
		Character *	passenger,
		bool	dead_passenger = `false`
	)

Definition at line 1146 of file map.cpp.

{
    // Mark the part as un-occupied regardless of whether there's a live passenger here.
    vp.part().remove_flag( vehicle_part::passenger_flag );
    vp.vehicle().invalidate_mass();
 
    if( !passenger ) {
        if( !dead_passenger ) {
            debugmsg( "map::unboard_vehicle: passenger not found" );
        }
        return;
    }
    passenger->in_vehicle = false;
    // Only make vehicle go out of control if the driver is the one unboarding.
    if( passenger->controlling_vehicle ) {
        vp.vehicle().skidding = true;
    }
    passenger->controlling_vehicle = false;
}

References Character::controlling_vehicle, debugmsg, Character::in_vehicle, vehicle::invalidate_mass(), vpart_reference::part(), vehicle_part::passenger_flag, vehicle_part::remove_flag(), vehicle::skidding, and vpart_reference::vehicle().

Referenced by board_vehicle(), detach_vehicle(), game::fling_creature(), talk_function::individual_mission(), game::is_game_over(), game::moving_vehicle_dismount(), game::phasing_move(), game::place_player(), game::place_player_overmap(), shake_vehicle(), game::swap_critters(), avatar_action::swim(), unboard_vehicle(), and game::vertical_move().

◆ update_lum()

void map::update_lum	(	item_location &	loc,
		bool	add
	)

Update luminosity before and after item's transformation.

Definition at line 4567 of file map.cpp.

{
    item *target = loc.get_item();
 
    // if the item is not emissive, do nothing
    if( !target->is_emissive() ) {
        return;
    }
 
    point l;
    submap *const current_submap = get_submap_at( loc.position(), l );
 
    if( add ) {
        current_submap->update_lum_add( l, *target );
    } else {
        current_submap->update_lum_rem( l, *target );
    }
}

References om_direction::add(), item_location::get_item(), get_submap_at(), item::is_emissive(), item_location::position(), submap::update_lum_add(), and submap::update_lum_rem().

Referenced by update_lum().

◆ update_pathfinding_cache()

void map::update_pathfinding_cache ( int zlev ) const

Definition at line 9004 of file map.cpp.

{
    auto &cache = get_pathfinding_cache( zlev );
    if( !cache.dirty ) {
        return;
    }
 
    std::uninitialized_fill_n( &cache.special[0][0], MAPSIZE_X * MAPSIZE_Y, PF_NORMAL );
 
    for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
        for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
            const auto cur_submap = get_submap_at_grid( { smx, smy, zlev } );
            if( !cur_submap ) {
                return;
            }
 
            tripoint p( 0, 0, zlev );
 
            for( int sx = 0; sx < SEEX; ++sx ) {
                p.x = sx + smx * SEEX;
                for( int sy = 0; sy < SEEY; ++sy ) {
                    p.y = sy + smy * SEEY;
 
                    pf_special cur_value = PF_NORMAL;
 
                    maptile tile( cur_submap, point( sx, sy ) );
 
                    const auto &terrain = tile.get_ter_t();
                    const auto &furniture = tile.get_furn_t();
                    int part;
                    const vehicle *veh = veh_at_internal( p, part );
 
                    const int cost = move_cost_internal( furniture, terrain, veh, part );
 
                    if( cost > 2 ) {
                        cur_value |= PF_SLOW;
                    } else if( cost <= 0 ) {
                        cur_value |= PF_WALL;
                        if( terrain.has_flag( TFLAG_CLIMBABLE ) ) {
                            cur_value |= PF_CLIMBABLE;
                        }
                    }
 
                    if( veh != nullptr ) {
                        cur_value |= PF_VEHICLE;
                    }
 
                    for( const auto &fld : tile.get_field() ) {
                        const field_entry &cur = fld.second;
                        const field_type_id type = cur.get_field_type();
                        const int field_intensity = cur.get_field_intensity();
                        if( type.obj().get_dangerous( field_intensity - 1 ) ) {
                            cur_value |= PF_FIELD;
                        }
                    }
 
                    if( !tile.get_trap_t().is_benign() || !terrain.trap.obj().is_benign() ) {
                        cur_value |= PF_TRAP;
                    }
 
                    if( terrain.has_flag( TFLAG_GOES_DOWN ) || terrain.has_flag( TFLAG_GOES_UP ) ||
                        terrain.has_flag( TFLAG_RAMP ) || terrain.has_flag( TFLAG_RAMP_UP ) ||
                        terrain.has_flag( TFLAG_RAMP_DOWN ) ) {
                        cur_value |= PF_UPDOWN;
                    }
 
                    if( terrain.has_flag( TFLAG_SHARP ) ) {
                        cur_value |= PF_SHARP;
                    }
 
                    cache.special[p.x][p.y] = cur_value;
                }
            }
        }
    }
 
    cache.dirty = false;
}

References furniture, maptile::get_field(), field_entry::get_field_intensity(), field_entry::get_field_type(), maptile::get_furn_t(), get_pathfinding_cache(), get_submap_at_grid(), maptile::get_ter_t(), maptile::get_trap_t(), trap::is_benign(), MAPSIZE_X, MAPSIZE_Y, move_cost_internal(), my_MAPSIZE, PF_CLIMBABLE, PF_FIELD, PF_NORMAL, PF_SHARP, PF_SLOW, PF_TRAP, PF_UPDOWN, PF_VEHICLE, PF_WALL, SEEX, SEEY, sx, sy, terrain, TFLAG_CLIMBABLE, TFLAG_GOES_DOWN, TFLAG_GOES_UP, TFLAG_RAMP, TFLAG_RAMP_DOWN, TFLAG_RAMP_UP, TFLAG_SHARP, type, veh_at_internal(), tripoint::x, and tripoint::y.

Referenced by get_pathfinding_cache_ref().

◆ update_submap_active_item_status()

void map::update_submap_active_item_status ( const tripoint & p )

Definition at line 5727 of file map.cpp.

{
    point l;
    submap *const current_submap = get_submap_at( p, l );
    if( current_submap->active_items.empty() ) {
        submaps_with_active_items.erase( tripoint( abs_sub.x + p.x / SEEX, abs_sub.y + p.y / SEEY, p.z ) );
    }
}

References abs_sub, submap::active_items, active_item_cache::empty(), get_submap_at(), SEEX, SEEY, submaps_with_active_items, tripoint::x, tripoint::y, and tripoint::z.

◆ update_suspension_cache()

void map::update_suspension_cache ( const int & z )

Definition at line 8205 of file map.cpp.

{
    level_cache &ch = get_cache( z );
    if( !ch.suspension_cache_dirty ) {
        return;
    }
    std::list<point> &suspension_cache = ch.suspension_cache;
    if( !ch.suspension_cache_initialized ) {
        for( int smx = 0; smx < my_MAPSIZE; ++smx ) {
            for( int smy = 0; smy < my_MAPSIZE; ++smy ) {
                const submap *cur_submap = get_submap_at_grid( { smx, smy, z } );
 
                if( cur_submap == nullptr ) {
                    debugmsg( "Tried to run suspension check at (%d,%d,%d) but the submap is not loaded", smx, smy,
                              z );
                    continue;
                }
 
                for( int sx = 0; sx < SEEX; ++sx ) {
                    for( int sy = 0; sy < SEEY; ++sy ) {
                        point sp( sx, sy );
                        const ter_t &terrain = cur_submap->get_ter( sp ).obj();
                        if( terrain.has_flag( TFLAG_SUSPENDED ) ) {
                            tripoint loc( coords::project_combine( point_om_sm( point( smx, smy ) ), point_sm_ms( sp ) ).raw(),
                                          z );
                            suspension_cache.emplace_back( getabs( loc ).xy() );
                        }
                    }
                }
            }
        }
        ch.suspension_cache_initialized = true;
    }
 
    for( auto iter = suspension_cache.begin(); iter != suspension_cache.end(); ) {
        const point absp = *iter;
        const point locp = getlocal( absp );
        const tripoint loctp( locp, z );
        if( !inbounds( locp ) ) {
            ++iter;
            continue;
        }
        const submap *cur_submap = get_submap_at( loctp );
        if( cur_submap == nullptr ) {
            debugmsg( "Tried to run suspension check at (%d,%d,%d) but the submap is not loaded", locp.x,
                      locp.y, z );
            ++iter;
            continue;
        }
        const ter_t &terrain = ter( locp ).obj();
        if( terrain.has_flag( TFLAG_SUSPENDED ) ) {
            if( !is_suspension_valid( loctp ) ) {
                support_dirty( loctp );
                iter = suspension_cache.erase( iter );
            } else {
                ++iter;
            }
        } else {
            iter = suspension_cache.erase( iter );
        }
    }
    ch.suspension_cache_dirty = false;
}

References debugmsg, get_cache(), get_submap_at(), get_submap_at_grid(), submap::get_ter(), getabs(), getlocal(), inbounds(), is_suspension_valid(), my_MAPSIZE, int_id< T >::obj(), coords::project_combine(), SEEX, SEEY, support_dirty(), level_cache::suspension_cache, level_cache::suspension_cache_dirty, level_cache::suspension_cache_initialized, sx, sy, ter(), terrain, TFLAG_SUSPENDED, point::x, and point::y.

Referenced by build_map_cache().

◆ update_vehicle_cache()

void map::update_vehicle_cache	(	vehicle *	,
		int	old_zlevel
	)

◆ update_vehicle_list()

void map::update_vehicle_list	(	const submap *	to,
		int	zlev
	)

Definition at line 400 of file map.cpp.

{
    // Update vehicle data
    level_cache &ch = get_cache( zlev );
    for( const auto &elem : to->vehicles ) {
        ch.vehicle_list.insert( elem.get() );
        if( !elem->loot_zones.empty() ) {
            ch.zone_vehicles.insert( elem.get() );
        }
    }
 
    last_full_vehicle_list_dirty = true;
}

References get_cache(), last_full_vehicle_list_dirty, level_cache::vehicle_list, submap::vehicles, and level_cache::zone_vehicles.

Referenced by displace_vehicle(), rotate(), shift(), and shift_vehicle_z().

◆ update_visibility_cache()

void map::update_visibility_cache ( int zlev )

Definition at line 5736 of file map.cpp.

{
    visibility_variables_cache.variables_set = true; // Not used yet
    visibility_variables_cache.g_light_level = static_cast<int>( g->light_level( zlev ) );
    visibility_variables_cache.vision_threshold = g->u.get_vision_threshold(
                get_cache_ref( g->u.posz() ).lm[g->u.posx()][g->u.posy()].max() );
 
    visibility_variables_cache.u_clairvoyance = g->u.clairvoyance();
    visibility_variables_cache.u_sight_impaired = g->u.sight_impaired();
    visibility_variables_cache.u_is_boomered = g->u.has_effect( effect_boomered );
 
    int sm_squares_seen[MAPSIZE][MAPSIZE];
    std::memset( sm_squares_seen, 0, sizeof( sm_squares_seen ) );
 
    int min_z = fov_3d ? -OVERMAP_DEPTH : zlev;
    int max_z = fov_3d ? OVERMAP_HEIGHT : zlev;
 
    for( int z = min_z; z <= max_z; z++ ) {
 
        auto &visibility_cache = get_cache( z ).visibility_cache;
 
        tripoint p;
        p.z = z;
        int &x = p.x;
        int &y = p.y;
        for( x = 0; x < MAPSIZE_X; x++ ) {
            for( y = 0; y < MAPSIZE_Y; y++ ) {
                lit_level ll = apparent_light_at( p, visibility_variables_cache );
                visibility_cache[x][y] = ll;
                if( z == zlev ) {
                    sm_squares_seen[ x / SEEX ][ y / SEEY ] += ( ll == lit_level::BRIGHT || ll == lit_level::LIT );
                }
            }
        }
    }
 
    for( int gridx = 0; gridx < my_MAPSIZE; gridx++ ) {
        for( int gridy = 0; gridy < my_MAPSIZE; gridy++ ) {
            if( sm_squares_seen[gridx][gridy] > 36 ) { // 25% of the submap is visible
                const tripoint sm( gridx, gridy, 0 );
                const auto abs_sm = map::abs_sub + sm;
                // TODO: fix point types
                const tripoint_abs_omt abs_omt( sm_to_omt_copy( abs_sm ) );
                overmap_buffer.set_seen( abs_omt, true );
            }
        }
    }
}

References abs_sub, apparent_light_at(), BRIGHT, effect_boomered, fov_3d, g, visibility_variables::g_light_level, get_cache(), get_cache_ref(), LIT, level_cache::lm, MAPSIZE, MAPSIZE_X, MAPSIZE_Y, four_quadrants::max(), my_MAPSIZE, overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, SEEX, SEEY, overmapbuffer::set_seen(), coords::sm, sm_to_omt_copy(), visibility_variables::u_clairvoyance, visibility_variables::u_is_boomered, visibility_variables::u_sight_impaired, visibility_variables::variables_set, level_cache::visibility_cache, visibility_variables_cache, visibility_variables::vision_threshold, tripoint::x, tripoint::y, and tripoint::z.

Referenced by game::draw(), draw(), game::get_player_input(), and game::look_around().

◆ use_amount()

std::list< item > map::use_amount	(	const tripoint &	origin,
		int	range,
		const itype_id &	type,
		int &	quantity,
		const std::function< bool(const item &)> &	filter = `return_true<item>`
	)

Definition at line 4940 of file map.cpp.

{
    std::list<item> ret;
    for( int radius = 0; radius <= range && quantity > 0; radius++ ) {
        for( const tripoint &p : points_in_radius( origin, radius ) ) {
            if( rl_dist( origin, p ) >= radius ) {
                std::list<item> tmp = use_amount_square( p, type, quantity, filter );
                ret.splice( ret.end(), tmp );
            }
        }
    }
    return ret;
}

References points_in_radius(), cata::hash64_detail::ret, rl_dist(), type, and use_amount_square().

◆ use_amount_square()

std::list< item > map::use_amount_square	(	const tripoint &	p,
		const itype_id &	type,
		int &	quantity,
		const std::function< bool(const item &)> &	filter = `return_true<item>`
	)

Definition at line 4918 of file map.cpp.

{
    std::list<item> ret;
    // Handle infinite map sources.
    item water = water_from( p );
    if( water.typeId() == type ) {
        ret.push_back( water );
        quantity = 0;
        return ret;
    }
 
    if( const std::optional<vpart_reference> vp = veh_at( p ).part_with_feature( "CARGO", true ) ) {
        std::list<item> tmp = use_amount_stack( vp->vehicle().get_items( vp->part_index() ), type,
                                                quantity, filter );
        ret.splice( ret.end(), tmp );
    }
    std::list<item> tmp = use_amount_stack( i_at( p ), type, quantity, filter );
    ret.splice( ret.end(), tmp );
    return ret;
}

References i_at(), cata::hash64_detail::ret, type, item::typeId(), use_amount_stack(), veh_at(), and water_from().

Referenced by use_amount().

◆ use_charges()

std::list< item > map::use_charges	(	const tripoint &	origin,
		int	range,
		const itype_id &	type,
		int &	quantity,
		const std::function< bool(const item &)> &	filter = `return_true<item>`,
		basecamp *	bcp = `nullptr`
	)

Definition at line 5038 of file map.cpp.

{
    std::list<item> ret;
 
    // populate a grid of spots that can be reached
    std::vector<tripoint> reachable_pts;
    reachable_flood_steps( reachable_pts, origin, range, 1, 100 );
 
    // We prefer infinite map sources where available, so search for those
    // first
    for( const tripoint &p : reachable_pts ) {
        // Handle infinite map sources.
        item water = water_from( p );
        if( water.typeId() == type ) {
            water.charges = quantity;
            ret.push_back( water );
            quantity = 0;
            return ret;
        }
    }
 
    if( bcp ) {
        ret = bcp->use_charges( type, quantity );
        if( quantity <= 0 ) {
            return ret;
        }
    }
 
    for( const tripoint &p : reachable_pts ) {
        if( has_furn( p ) ) {
            use_charges_from_furn( furn( p ).obj(), type, quantity, this, p, ret, filter );
            if( quantity <= 0 ) {
                return ret;
            }
        }
 
        if( accessible_items( p ) ) {
            std::list<item> tmp = use_charges_from_stack( i_at( p ), type, quantity, p, filter );
            ret.splice( ret.end(), tmp );
            if( quantity <= 0 ) {
                return ret;
            }
        }
 
        const optional_vpart_position vp = veh_at( p );
        if( !vp ) {
            continue;
        }
 
        const std::optional<vpart_reference> kpart = vp.part_with_feature( "FAUCET", true );
        const std::optional<vpart_reference> weldpart = vp.part_with_feature( "WELDRIG", true );
        const std::optional<vpart_reference> craftpart = vp.part_with_feature( "CRAFTRIG", true );
        const std::optional<vpart_reference> forgepart = vp.part_with_feature( "FORGE", true );
        const std::optional<vpart_reference> kilnpart = vp.part_with_feature( "KILN", true );
        const std::optional<vpart_reference> chempart = vp.part_with_feature( "CHEMLAB", true );
        const std::optional<vpart_reference> autoclavepart = vp.part_with_feature( "AUTOCLAVE", true );
        const std::optional<vpart_reference> cargo = vp.part_with_feature( "CARGO", true );
 
        if( kpart ) { // we have a faucet, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            // Special case hotplates which draw battery power
            if( type == itype_hotplate ) {
                ftype = itype_battery;
            } else {
                ftype = type;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = kpart->vehicle().drain( ftype, quantity );
            // TODO: Handle water poison when crafting starts respecting it
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( weldpart ) { // we have a weldrig, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_welder ) {
                ftype = itype_battery;
            } else if( type == itype_soldering_iron ) {
                ftype = itype_battery;
            }
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = weldpart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( craftpart ) { // we have a craftrig, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_press ) {
                ftype = itype_battery;
            } else if( type == itype_vac_sealer ) {
                ftype = itype_battery;
            } else if( type == itype_dehydrator ) {
                ftype = itype_battery;
            } else if( type == itype_food_processor ) {
                ftype = itype_battery;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = craftpart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( forgepart ) { // we have a veh_forge, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_forge ) {
                ftype = itype_battery;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = forgepart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( kilnpart ) { // we have a veh_kiln, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_kiln ) {
                ftype = itype_battery;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = kilnpart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( chempart ) { // we have a chem_lab, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_chemistry_set ) {
                ftype = itype_battery;
            } else if( type == itype_hotplate ) {
                ftype = itype_battery;
            } else if( type == itype_electrolysis_kit ) {
                ftype = itype_battery;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = chempart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( autoclavepart ) { // we have an autoclave, now to see what to drain
            itype_id ftype = itype_id::NULL_ID();
 
            if( type == itype_autoclave ) {
                ftype = itype_battery;
            }
 
            // TODO: add a sane birthday arg
            item tmp( type, calendar::start_of_cataclysm );
            tmp.charges = autoclavepart->vehicle().drain( ftype, quantity );
            quantity -= tmp.charges;
            ret.push_back( tmp );
 
            if( quantity == 0 ) {
                return ret;
            }
        }
 
        if( cargo ) {
            std::list<item> tmp =
                use_charges_from_stack( cargo->vehicle().get_items( cargo->part_index() ), type, quantity, p,
                                        filter );
            ret.splice( ret.end(), tmp );
            if( quantity <= 0 ) {
                return ret;
            }
        }
    }
 
    return ret;
}

References accessible_items(), item::charges, furn(), has_furn(), i_at(), itype_autoclave, itype_battery, itype_chemistry_set, itype_dehydrator, itype_electrolysis_kit, itype_food_processor, itype_forge, itype_hotplate, itype_kiln, itype_press, itype_soldering_iron, itype_vac_sealer, itype_welder, string_id< itype >::NULL_ID(), optional_vpart_position::part_with_feature(), range, reachable_flood_steps(), cata::hash64_detail::ret, calendar::start_of_cataclysm, type, item::typeId(), basecamp::use_charges(), use_charges_from_furn(), use_charges_from_stack(), veh_at(), and water_from().

Referenced by basecamp_action_components::consume_components(), player::consume_items(), player::consume_tools(), and iexamine::use_furn_fake_item().

◆ valid_move()

bool map::valid_move	(	const tripoint &	from,
		const tripoint &	to,
		bool	bash = `false`,
		bool	flying = `false`,
		bool	via_ramp = `false`
	)		const

Returns true if a creature could walk from from to to in one step.

That is, if the tiles are adjacent and either on the same z-level or connected by stairs or (in case of flying monsters) open air with no floors.

Definition at line 1926 of file map.cpp.

{
    // Used to account for the fact that older versions of GCC can trip on the if statement here.
    assert( to.z > std::numeric_limits<int>::min() );
    // Note: no need to check inbounds here, because maptile_at will do that
    // If oob tile is supplied, the maptile_at will be an unpassable "null" tile
    if( std::abs( from.x - to.x ) > 1 || std::abs( from.y - to.y ) > 1 ||
        std::abs( from.z - to.z ) > 1 ) {
        return false;
    }
 
    if( from.z == to.z ) {
        // But here we need to, to prevent bashing critters
        return passable( to ) || ( bash && inbounds( to ) );
    } else if( !zlevels ) {
        return false;
    }
 
    const bool going_up = from.z < to.z;
 
    const tripoint &up_p = going_up ? to : from;
    const tripoint &down_p = going_up ? from : to;
 
    const maptile up = maptile_at( up_p );
    const ter_t &up_ter = up.get_ter_t();
    if( up_ter.id.is_null() ) {
        return false;
    }
    // Checking for ledge is a workaround for the case when mapgen doesn't
    // actually make a valid ledge drop location with zlevels on, this forces
    // at least one zlevel drop and if down_ter is impassible it's probably
    // inside a wall, we could workaround that further but it's unnecessary.
    const bool up_is_ledge = tr_at( up_p ).loadid == tr_ledge;
 
    if( up_ter.movecost == 0 ) {
        // Unpassable tile
        return false;
    }
 
    const maptile down = maptile_at( down_p );
    const ter_t &down_ter = down.get_ter_t();
    if( down_ter.id.is_null() ) {
        return false;
    }
 
    if( !up_is_ledge && down_ter.movecost == 0 ) {
        // Unpassable tile
        return false;
    }
 
    if( !up_ter.has_flag( TFLAG_NO_FLOOR ) && !up_ter.has_flag( TFLAG_GOES_DOWN ) && !up_is_ledge &&
        !via_ramp ) {
        // Can't move from up to down
        if( std::abs( from.x - to.x ) == 1 || std::abs( from.y - to.y ) == 1 ) {
            // Break the move into two - vertical then horizontal
            tripoint midpoint( down_p.xy(), up_p.z );
            return valid_move( down_p, midpoint, bash, flying, via_ramp ) &&
                   valid_move( midpoint, up_p, bash, flying, via_ramp );
        }
        return false;
    }
 
    if( !flying && !down_ter.has_flag( TFLAG_GOES_UP ) && !down_ter.has_flag( TFLAG_RAMP ) &&
        !up_is_ledge && !via_ramp ) {
        // Can't safely reach the lower tile
        return false;
    }
 
    if( bash ) {
        return true;
    }
 
    int part_up;
    const vehicle *veh_up = veh_at_internal( up_p, part_up );
    if( veh_up != nullptr ) {
        // TODO: Hatches below the vehicle, passable frames
        return false;
    }
 
    int part_down;
    const vehicle *veh_down = veh_at_internal( down_p, part_down );
    if( veh_down != nullptr && veh_down->roof_at_part( part_down ) >= 0 ) {
        // TODO: OPEN (and only open) hatches from above
        return false;
    }
 
    // Currently only furniture can block movement if everything else is OK
    // TODO: Vehicles with boards in the given spot
    return up.get_furn_t().movecost >= 0;
}

References bash(), map_data_common_t::has_flag(), ter_t::id, inbounds(), string_id< T >::is_null(), trap::loadid, maptile_at(), midpoint(), map_data_common_t::movecost, passable(), vehicle::roof_at_part(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, TFLAG_NO_FLOOR, TFLAG_RAMP, tr_at(), tr_ledge, valid_move(), veh_at_internal(), tripoint::x, tripoint::xy(), tripoint::y, tripoint::z, and zlevels.

Referenced by combined_movecost(), draw_critter_internal(), has_floor_or_support(), scent_map::inbounds(), process_fields_in_submap(), route(), spread_gas(), and valid_move().

◆ veh_at() [1/2]

optional_vpart_position map::veh_at ( const tripoint & p ) const

Checks if tile is occupied by vehicle and by which part.

Parameters

p	Tile to check for vehicle

Definition at line 1074 of file map.cpp.

{
    if( !inbounds( p ) || !const_cast<map *>( this )->get_cache( p.z ).veh_in_active_range ) {
        return optional_vpart_position( std::nullopt );
    }
 
    int part_num = 1;
    vehicle *const veh = const_cast<map *>( this )->veh_at_internal( p, part_num );
    if( !veh ) {
        return optional_vpart_position( std::nullopt );
    }
    return optional_vpart_position( vpart_position( *veh, part_num ) );
 
}

References get_cache(), inbounds(), veh_at_internal(), level_cache::veh_in_active_range, and tripoint::z.

◆ veh_at() [2/2]

optional_vpart_position map::veh_at ( const tripoint_abs_ms & p ) const

Definition at line 1069 of file map.cpp.

{
    return veh_at( getlocal( p ) );
}

References getlocal(), and veh_at().

◆ veh_at_internal() [1/2]

vehicle * map::veh_at_internal	(	const tripoint &	p,
		int &	part_num
	)

Definition at line 1109 of file map.cpp.

{
    return const_cast<vehicle *>( const_cast<const map *>( this )->veh_at_internal( p, part_num ) );
}

References veh_at_internal().

Referenced by draw_from_above(), draw_maptile(), process_fields_in_submap(), route(), update_pathfinding_cache(), valid_move(), veh_at(), and veh_at_internal().

◆ veh_at_internal() [2/2]

const vehicle * map::veh_at_internal	(	const tripoint &	p,
		int &	part_num
	)		const

Definition at line 1089 of file map.cpp.

{
    // This function is called A LOT. Move as much out of here as possible.
    const level_cache &ch = get_cache( p.z );
    if( !ch.veh_in_active_range || !ch.veh_exists_at[p.x][p.y] ) {
        part_num = -1;
        return nullptr; // Clear cache indicates no vehicle. This should optimize a great deal.
    }
 
    const auto it = ch.veh_cached_parts.find( p );
    if( it != ch.veh_cached_parts.end() ) {
        part_num = it->second.second;
        return it->second.first;
    }
 
    debugmsg( "vehicle part cache indicated vehicle not found: %d %d %d", p.x, p.y, p.z );
    part_num = -1;
    return nullptr;
}

References debugmsg, get_cache(), level_cache::veh_cached_parts, level_cache::veh_exists_at, level_cache::veh_in_active_range, tripoint::x, tripoint::y, and tripoint::z.

◆ vehicle_vehicle_collision()

float map::vehicle_vehicle_collision	(	vehicle &	veh,
		vehicle &	veh2,
		const std::vector< veh_collision > &	collisions
	)

Definition at line 822 of file map.cpp.

{
    if( &veh == &veh2 ) {
        debugmsg( "Vehicle %s collided with itself", veh.name );
        return 0.0f;
    }
 
    // Effects of colliding with another vehicle:
    //  transfers of momentum, skidding,
    //  parts are damaged/broken on both sides,
    //  remaining times are normalized
    const veh_collision &c = collisions[0];
    add_msg( m_bad, _( "The %1$s's %2$s collides with %3$s's %4$s." ),
             veh.name,  veh.part_info( c.part ).name(),
             veh2.name, veh2.part_info( c.target_part ).name() );
 
    const bool vertical = veh.sm_pos.z != veh2.sm_pos.z;
 
    // Used to calculate the epicenter of the collision.
    point epicenter1;
    point epicenter2;
 
    float dmg;
    // Vertical collisions will be simpler for a while (1D)
    if( !vertical ) {
        // For reference, a cargo truck weighs ~25300, a bicycle 690,
        //  and 38mph is 3800 'velocity'
        rl_vec2d velo_veh1 = veh.velo_vec();
        rl_vec2d velo_veh2 = veh2.velo_vec();
        const float m1 = to_kilogram( veh.total_mass() );
        const float m2 = to_kilogram( veh2.total_mass() );
        //Energy of vehicle1 and vehicle2 before collision
        float E = 0.5 * m1 * velo_veh1.magnitude() * velo_veh1.magnitude() +
                  0.5 * m2 * velo_veh2.magnitude() * velo_veh2.magnitude();
 
        // Collision_axis
        point cof1 = veh .rotated_center_of_mass();
        point cof2 = veh2.rotated_center_of_mass();
        int &x_cof1 = cof1.x;
        int &y_cof1 = cof1.y;
        int &x_cof2 = cof2.x;
        int &y_cof2 = cof2.y;
        rl_vec2d collision_axis_y;
 
        collision_axis_y.x = ( veh.global_pos3().x + x_cof1 ) - ( veh2.global_pos3().x + x_cof2 );
        collision_axis_y.y = ( veh.global_pos3().y + y_cof1 ) - ( veh2.global_pos3().y + y_cof2 );
        collision_axis_y = collision_axis_y.normalized();
        rl_vec2d collision_axis_x = collision_axis_y.rotated( M_PI / 2 );
        // imp? & delta? & final? reworked:
        // newvel1 =( vel1 * ( mass1 - mass2 ) + ( 2 * mass2 * vel2 ) ) / ( mass1 + mass2 )
        // as per http://en.wikipedia.org/wiki/Elastic_collision
        //velocity of veh1 before collision in the direction of collision_axis_y
        float vel1_y = collision_axis_y.dot_product( velo_veh1 );
        float vel1_x = collision_axis_x.dot_product( velo_veh1 );
        //velocity of veh2 before collision in the direction of collision_axis_y
        float vel2_y = collision_axis_y.dot_product( velo_veh2 );
        float vel2_x = collision_axis_x.dot_product( velo_veh2 );
        // e = 0 -> inelastic collision
        // e = 1 -> elastic collision
        float e = get_collision_factor( vel1_y / 100 - vel2_y / 100 );
 
        // Velocity after collision
        // vel1_x_a = vel1_x, because in x-direction we have no transmission of force
        float vel1_x_a = vel1_x;
        float vel2_x_a = vel2_x;
        // Transmission of force only in direction of collision_axix_y
        // Equation: partially elastic collision
        float vel1_y_a = ( m2 * vel2_y * ( 1 + e ) + vel1_y * ( m1 - m2 * e ) ) / ( m1 + m2 );
        float vel2_y_a = ( m1 * vel1_y * ( 1 + e ) + vel2_y * ( m2 - m1 * e ) ) / ( m1 + m2 );
        // Add both components; Note: collision_axis is normalized
        rl_vec2d final1 = collision_axis_y * vel1_y_a + collision_axis_x * vel1_x_a;
        rl_vec2d final2 = collision_axis_y * vel2_y_a + collision_axis_x * vel2_x_a;
 
        veh.move.init( final1.as_point() );
        if( final1.dot_product( veh.face_vec() ) < 0 ) {
            // Car is being pushed backwards. Make it move backwards
            veh.velocity = -final1.magnitude();
        } else {
            veh.velocity = final1.magnitude();
        }
 
        veh2.move.init( final2.as_point() );
        if( final2.dot_product( veh2.face_vec() ) < 0 ) {
            // Car is being pushed backwards. Make it move backwards
            veh2.velocity = -final2.magnitude();
        } else {
            veh2.velocity = final2.magnitude();
        }
 
        //give veh2 the initiative to proceed next before veh1
        float avg_of_turn = ( veh2.of_turn + veh.of_turn ) / 2;
        if( avg_of_turn < .1f ) {
            avg_of_turn = .1f;
        }
 
        veh.of_turn = avg_of_turn * .9;
        veh2.of_turn = avg_of_turn * 1.1;
 
        //Energy after collision
        float E_a = 0.5 * m1 * final1.magnitude() * final1.magnitude() +
                    0.5 * m2 * final2.magnitude() * final2.magnitude();
        float d_E = E - E_a;  //Lost energy at collision -> deformation energy
        dmg = std::abs( d_E / 1000 / 2000 );  //adjust to balance damage
    } else {
        const float m1 = to_kilogram( veh.total_mass() );
        // Collision is perfectly inelastic for simplicity
        // Assume veh2 is standing still
        dmg = std::abs( veh.vertical_velocity / 100 ) * m1 / 10;
        veh.vertical_velocity = 0;
    }
 
    float dmg_veh1 = dmg * 0.5;
    float dmg_veh2 = dmg * 0.5;
 
    int coll_parts_cnt = 0; //quantity of colliding parts between veh1 and veh2
    for( const auto &veh_veh_coll : collisions ) {
        if( &veh2 == static_cast<vehicle *>( veh_veh_coll.target ) ) {
            coll_parts_cnt++;
        }
    }
 
    const float dmg1_part = dmg_veh1 / coll_parts_cnt;
    const float dmg2_part = dmg_veh2 / coll_parts_cnt;
 
    //damage colliding parts (only veh1 and veh2 parts)
    for( const auto &veh_veh_coll : collisions ) {
        if( &veh2 != static_cast<vehicle *>( veh_veh_coll.target ) ) {
            continue;
        }
 
        int parm1 = veh.part_with_feature( veh_veh_coll.part, VPFLAG_ARMOR, true );
        if( parm1 < 0 ) {
            parm1 = veh_veh_coll.part;
        }
        int parm2 = veh2.part_with_feature( veh_veh_coll.target_part, VPFLAG_ARMOR, true );
        if( parm2 < 0 ) {
            parm2 = veh_veh_coll.target_part;
        }
 
        epicenter1 += veh.part( parm1 ).mount;
        veh.damage( parm1, dmg1_part, DT_BASH );
 
        epicenter2 += veh2.part( parm2 ).mount;
        veh2.damage( parm2, dmg2_part, DT_BASH );
    }
 
    epicenter2.x /= coll_parts_cnt;
    epicenter2.y /= coll_parts_cnt;
 
    if( dmg2_part > 100 ) {
        // Shake vehicle because of collision
        veh2.damage_all( dmg2_part / 2, dmg2_part, DT_BASH, epicenter2 );
    }
 
    if( dmg_veh1 > 800 ) {
        veh.skidding = true;
    }
 
    if( dmg_veh2 > 800 ) {
        veh2.skidding = true;
    }
 
    // Return the impulse of the collision
    return dmg_veh1;
}

References _, add_msg(), rl_vec2d::as_point(), c, vehicle::damage(), vehicle::damage_all(), debugmsg, rl_vec2d::dot_product(), DT_BASH, vehicle::face_vec(), get_collision_factor(), vehicle::global_pos3(), tileray::init(), m_bad, M_PI, rl_vec2d::magnitude(), vehicle_part::mount, vehicle::move, vpart_info::name(), vehicle::name, rl_vec2d::normalized(), vehicle::of_turn, vehicle::part(), vehicle::part_info(), vehicle::part_with_feature(), rl_vec2d::rotated(), vehicle::rotated_center_of_mass(), vehicle::skidding, vehicle::sm_pos, units::to_kilogram(), vehicle::total_mass(), vehicle::velo_vec(), vehicle::velocity, vehicle::vertical_velocity, VPFLAG_ARMOR, point::x, tripoint::x, rl_vec2d::x, point::y, tripoint::y, rl_vec2d::y, and tripoint::z.

Referenced by move_vehicle().

◆ vehicle_wheel_traction()

float map::vehicle_wheel_traction	(	const vehicle &	veh,
		bool	ignore_movement_modifiers = `false`
	)		const

Definition at line 1587 of file vehicle_move.cpp.

{
    if( veh.is_in_water( true ) ) {
        return veh.can_float() ? 1.0f : -1.0f;
    }
    if( veh.is_in_water() && veh.is_watercraft() && veh.can_float() ) {
        return 1.0f;
    }
 
    const auto &wheel_indices = veh.wheelcache;
    int num_wheels = wheel_indices.size();
    if( num_wheels == 0 ) {
        // TODO: Assume it is digging in dirt
        // TODO: Return something that could be reused for dragging
        return 0.0f;
    }
 
    float traction_wheel_area = 0.0f;
 
    if( vehicle_movement::is_on_rails( *this, veh ) ) {
        // Vehicles on rails are considered to have all of their wheels on rails
        for( int p : veh.rail_wheelcache ) {
            traction_wheel_area += veh.cpart( p ).wheel_area();
        }
        return traction_wheel_area;
    }
 
    for( int p : wheel_indices ) {
        const tripoint &pp = veh.global_part_pos3( p );
        const int wheel_area = veh.cpart( p ).wheel_area();
 
        const auto &tr = ter( pp ).obj();
        // Deep water and air
        if( tr.has_flag( TFLAG_DEEP_WATER ) || tr.has_flag( TFLAG_NO_FLOOR ) ) {
            // No traction from wheel in water or air
            continue;
        }
 
        int move_mod = move_cost_ter_furn( pp );
        if( move_mod == 0 ) {
            // Vehicle locked in wall
            // Shouldn't happen, but does
            return 0.0f;
        }
 
        for( const auto &terrain_mod : veh.part_info( p ).wheel_terrain_mod() ) {
            if( !tr.has_flag( terrain_mod.first ) ) {
                move_mod += terrain_mod.second;
                break;
            }
        }
 
        // Ignore the movement modifier if needed.
        if( ignore_movement_modifiers ) {
            move_mod = 2;
        }
 
        traction_wheel_area += 2.0 * wheel_area / move_mod;
    }
 
    return traction_wheel_area;
}

References vehicle::can_float(), vehicle::cpart(), vehicle::global_part_pos3(), vehicle::is_in_water(), vehicle_movement::is_on_rails(), vehicle::is_watercraft(), move_cost_ter_furn(), int_id< T >::obj(), vehicle::part_info(), vehicle::rail_wheelcache, ter(), TFLAG_DEEP_WATER, TFLAG_NO_FLOOR, vehicle_part::wheel_area(), vpart_info::wheel_terrain_mod(), and vehicle::wheelcache.

Referenced by move_vehicle().

◆ vehmove()

void map::vehmove ( )

Definition at line 474 of file map.cpp.

{
    // give vehicles movement points
    VehicleList vehicle_list;
    int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int zlev = minz; zlev <= maxz; ++zlev ) {
        level_cache &cache = get_cache( zlev );
        for( vehicle *veh : cache.vehicle_list ) {
            veh->gain_moves();
            veh->slow_leak();
            wrapped_vehicle w;
            w.v = veh;
            vehicle_list.push_back( w );
        }
    }
 
    // 15 equals 3 >50mph vehicles, or up to 15 slow (1 square move) ones
    // But 15 is too low for V12 death-bikes, let's put 100 here
    for( int count = 0; count < 100; count++ ) {
        if( !vehproceed( vehicle_list ) ) {
            break;
        }
    }
    // Process item removal on the vehicles that were modified this turn.
    // Use a copy because part_removal_cleanup can modify the container.
    auto temp = dirty_vehicle_list;
    for( const auto &elem : temp ) {
        auto same_ptr = [ elem ]( const struct wrapped_vehicle & tgt ) {
            return elem == tgt.v;
        };
        if( std::find_if( vehicle_list.begin(), vehicle_list.end(), same_ptr ) !=
            vehicle_list.end() ) {
            elem->part_removal_cleanup();
        }
    }
    dirty_vehicle_list.clear();
    // The bool tracks whether the vehicles is on the map or not.
    std::map<vehicle *, bool> connected_vehicles;
    for( int zlev = minz; zlev <= maxz; ++zlev ) {
        level_cache &cache = get_cache( zlev );
        vehicle::enumerate_vehicles( connected_vehicles, cache.vehicle_list );
    }
    for( std::pair<vehicle *const, bool> &veh_pair : connected_vehicles ) {
        veh_pair.first->idle( veh_pair.second );
    }
}

References abs_sub, detail::count(), dirty_vehicle_list, vehicle::enumerate_vehicles(), vehicle::gain_moves(), get_cache(), OVERMAP_DEPTH, OVERMAP_HEIGHT, vehicle::slow_leak(), wrapped_vehicle::v, level_cache::vehicle_list, vehproceed(), tripoint::z, and zlevels.

Referenced by game::do_turn().

◆ vehproceed()

bool map::vehproceed ( VehicleList & vehicle_list )

Definition at line 522 of file map.cpp.

{
    wrapped_vehicle *cur_veh = nullptr;
    float max_of_turn = 0;
    // First horizontal movement
    for( wrapped_vehicle &vehs_v : vehicle_list ) {
        if( vehs_v.v->of_turn > max_of_turn ) {
            cur_veh = &vehs_v;
            max_of_turn = cur_veh->v->of_turn;
        }
    }
 
    // Then vertical-only movement
    if( cur_veh == nullptr ) {
        for( wrapped_vehicle &vehs_v : vehicle_list ) {
            if( vehs_v.v->is_falling || ( vehs_v.v->is_rotorcraft() && vehs_v.v->get_z_change() != 0 ) ) {
                cur_veh = &vehs_v;
                break;
            }
        }
    }
 
    if( cur_veh == nullptr ) {
        return false;
    }
 
    cur_veh->v = cur_veh->v->act_on_map();
    if( cur_veh->v == nullptr ) {
        vehicle_list = get_vehicles();
    }
 
    // confirm that veh_in_active_range is still correct for each z-level
    int minz = zlevels ? -OVERMAP_DEPTH : abs_sub.z;
    int maxz = zlevels ? OVERMAP_HEIGHT : abs_sub.z;
    for( int zlev = minz; zlev <= maxz; ++zlev ) {
        level_cache &cache = get_cache( zlev );
 
        // Check if any vehicles exist in the active range for this z-level
        cache.veh_in_active_range = cache.veh_in_active_range &&
                                    std::any_of( std::begin( cache.veh_exists_at ),
        std::end( cache.veh_exists_at ), []( const auto & row ) {
            return std::any_of( std::begin( row ), std::end( row ), []( bool veh_exists ) {
                return veh_exists;
            } );
        } );
    }
 
    return true;
}

References abs_sub, vehicle::act_on_map(), get_cache(), get_vehicles(), vehicle::of_turn, OVERMAP_DEPTH, OVERMAP_HEIGHT, wrapped_vehicle::v, level_cache::veh_exists_at, level_cache::veh_in_active_range, tripoint::z, and zlevels.

Referenced by vehmove().

◆ vertical_shift()

void map::vertical_shift ( int newz )

Moves the map vertically to (not by!) newz.

Does not actually shift anything, only forces cache updates. In the future, it will either actually shift the map or it will get removed after 3D migration is complete.

Definition at line 7050 of file map.cpp.

{
    if( !zlevels ) {
        debugmsg( "Called map::vertical_shift in a non-z-level world" );
        return;
    }
 
    if( newz < -OVERMAP_DEPTH || newz > OVERMAP_HEIGHT ) {
        debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
                  newz, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
        return;
    }
 
    tripoint trp = get_abs_sub();
    set_abs_sub( tripoint( trp.xy(), newz ) );
 
    // TODO: Remove the function when it's safe
    return;
}

References debugmsg, get_abs_sub(), OVERMAP_DEPTH, OVERMAP_HEIGHT, set_abs_sub(), tripoint::xy(), and zlevels.

Referenced by game::vertical_shift().

◆ water_from()

item map::water_from ( const tripoint & p )

Definition at line 4506 of file map.cpp.

{
    if( has_flag( "SALT_WATER", p ) ) {
        return item( "salt_water", calendar::start_of_cataclysm, item::INFINITE_CHARGES );
    }
 
    const ter_id terrain_id = ter( p );
    if( terrain_id == t_sewage ) {
        item ret( "water_sewage", calendar::start_of_cataclysm, item::INFINITE_CHARGES );
        ret.poison = rng( 1, 7 );
        return ret;
    }
 
    item ret( "water", calendar::start_of_cataclysm, item::INFINITE_CHARGES );
    // iexamine::water_source requires a valid liquid from this function.
    if( terrain_id.obj().examine == &iexamine::water_source ) {
        int poison_chance = 0;
        if( terrain_id.obj().has_flag( TFLAG_DEEP_WATER ) ) {
            if( terrain_id.obj().has_flag( TFLAG_CURRENT ) ) {
                poison_chance = 20;
            } else {
                poison_chance = 4;
            }
        } else {
            if( terrain_id.obj().has_flag( TFLAG_CURRENT ) ) {
                poison_chance = 10;
            } else {
                poison_chance = 3;
            }
        }
        if( one_in( poison_chance ) ) {
            ret.poison = rng( 1, 4 );
        }
        return ret;
    }
    if( furn( p ).obj().examine == &iexamine::water_source ) {
        return ret;
    }
    return item();
}

References examine(), map_data_common_t::examine, furn(), map_data_common_t::has_flag(), has_flag(), item::INFINITE_CHARGES, int_id< T >::obj(), one_in(), cata::hash64_detail::ret, rng(), calendar::start_of_cataclysm, t_sewage, ter(), TFLAG_CURRENT, TFLAG_DEEP_WATER, and iexamine::water_source().

Referenced by inventory::form_from_map(), use_amount_square(), and use_charges().

Friends And Related Function Documentation

◆ editmap

friend class editmap

friend

Definition at line 385 of file map.h.

◆ visitable< map_cursor >

friend class visitable< map_cursor >

friend

Definition at line 385 of file map.h.

Member Data Documentation

◆ abs_sub

tripoint map::abs_sub

protected

Absolute coordinates of first submap (get_submap_at(0,0)) This is in submap coordinates (see overmapbuffer for explanation).

It is set upon:

loading submap at grid[0],
generating submaps (generate)
shifting the map with shift

Definition at line 1801 of file map.h.

Referenced by add_item(), add_item_or_charges(), add_vehicle(), adjust_radiation(), apply_faction_ownership(), bash_rating(), bash_resistance(), bash_strength(), build_floor_caches(), can_put_items(), can_put_items_ter_furn(), check_submap_active_item_consistency(), clear_vehicle_cache(), create_anomaly(), decay_fields_and_scent(), detach_vehicle(), draw_fill_background(), draw_lab(), draw_mine(), draw_temple(), draw_triffid(), features(), furn(), furn_set(), furnname(), generate(), get_abs_sub(), get_active_items_in_radius(), get_nonant(), get_submap_at(), get_vehicles(), getabs(), getlocal(), has_flag(), has_flag_furn(), has_flag_ter(), has_flag_ter_or_furn(), has_furn(), i_at(), i_clear(), i_rem(), is_bashable(), is_bashable_furn(), is_bashable_ter(), is_bashable_ter_furn(), is_divable(), is_outside(), is_water_shallow_current(), loadn(), make_active(), move_cost(), move_cost_ter_furn(), name(), passable(), place_items(), place_npc(), place_vending(), points_on_zlevel(), process_fields(), process_fields_in_submap(), process_items(), reset_vehicle_cache(), rotate(), save(), saven(), scent_blockers(), set_abs_sub(), set_radiation(), set_temperature(), spawn_an_item(), spawn_item(), spawn_items(), spawn_monsters(), spawn_monsters_submap(), spawn_monsters_submap_group(), ter(), ter_set(), tername(), update_submap_active_item_status(), update_visibility_cache(), vehmove(), and vehproceed().

◆ caches

std::array< std::unique_ptr<level_cache>, OVERMAP_LAYERS > map::caches

private

Holds caches for visibility, light, transparency and vehicles.

Definition at line 1973 of file map.h.

Referenced by access_cache(), get_cache(), get_cache_ref(), and map().

◆ dirty_vehicle_list

std::set<vehicle *> map::dirty_vehicle_list

Definition at line 1600 of file map.h.

Referenced by detach_vehicle(), loadn(), MapgenRemovePartHandler::removed(), and vehmove().

◆ field_furn_locs

std::vector<tripoint> map::field_furn_locs

private

Vector of tripoints containing active field-emitting furniture.

Definition at line 1969 of file map.h.

Referenced by actualize(), furn_set(), get_furn_field_locations(), load(), and shift_traps().

◆ grid

std::vector<submap *> map::grid

private

The list of currently loaded submaps.

The size of this should not be changed. After calling load or generate, it should only contain non-null pointers. Use getsubmap or setsubmap to access it.

Definition at line 1958 of file map.h.

Referenced by actualize(), add_roofs(), clear_spawns(), clear_traps(), editmap::cleartmpmap(), displace_vehicle(), getsubmap(), loadn(), map(), saven(), and setsubmap().

◆ last_full_vehicle_list

VehicleList map::last_full_vehicle_list

private

Vehicle list doesn't change often, but is pretty expensive.

Definition at line 1989 of file map.h.

Referenced by get_vehicles().

◆ last_full_vehicle_list_dirty

bool map::last_full_vehicle_list_dirty = true

private

Definition at line 1990 of file map.h.

Referenced by add_vehicle_to_cache(), clear_vehicle_list(), get_vehicles(), reset_vehicle_cache(), and update_vehicle_list().

◆ max_populated_zlev

std::optional<std::pair<tripoint, int> > map::max_populated_zlev = std::nullopt

private

Definition at line 2003 of file map.h.

Referenced by calc_max_populated_zlev(), and invalidate_max_populated_zlev().

◆ my_MAPSIZE

int map::my_MAPSIZE

protected

◆ pathfinding_caches

std::array< std::unique_ptr<pathfinding_cache>, OVERMAP_LAYERS > map::pathfinding_caches

mutableprivate

Definition at line 1975 of file map.h.

Referenced by get_pathfinding_cache(), get_pathfinding_cache_ref(), and map().

◆ skew_vision_cache

lru_cache<point, char> map::skew_vision_cache

mutableprivate

Cache of coordinate pairs recently checked for visibility.

Definition at line 1984 of file map.h.

Referenced by build_map_cache(), and sees().

◆ submaps_with_active_items

std::set<tripoint> map::submaps_with_active_items

private

Set of submaps that contain active items in absolute coordinates.

Definition at line 1979 of file map.h.

Referenced by add_item(), check_submap_active_item_consistency(), get_active_items_in_radius(), get_submaps_with_active_items(), i_clear(), i_rem(), load(), loadn(), make_active(), process_items(), shift(), and update_submap_active_item_status().

◆ support_cache_dirty

std::set<tripoint> map::support_cache_dirty

private

Definition at line 1499 of file map.h.

Referenced by process_falling(), shift(), support_dirty(), and ter_set().

◆ traplocs

std::vector< std::vector<tripoint> > map::traplocs

private

This vector contains an entry for each trap type, it has therefor the same size as the traplist vector.

Each entry contains a list of all point on the map that contain a trap of that type. The first entry however is always empty as it denotes the tr_null trap.

Definition at line 1965 of file map.h.

Referenced by actualize(), clear_traps(), load(), map(), remove_trap(), shift_traps(), ter_set(), trap_locations(), and trap_set().

◆ visibility_variables_cache

visibility_variables map::visibility_variables_cache

private

Definition at line 1999 of file map.h.

Referenced by get_visibility_variables_cache(), and update_visibility_cache().

◆ vision_transparency_cache

vision_adjustment map::vision_transparency_cache[8] = { VISION_ADJUST_NONE }

protected

Definition at line 1791 of file map.h.

Referenced by apply_vision_transparency_cache(), and build_vision_transparency_cache().

◆ zlevels

bool map::zlevels

protected

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Friends

Consume items on the map

Detailed Description

Member Enumeration Documentation

◆ iteration_state

Constructor & Destructor Documentation

◆ map() [1/2]

◆ map() [2/2]

◆ ~map()

Member Function Documentation

◆ access_cache() [1/2]

◆ access_cache() [2/2]

◆ accessible_items()

◆ actualize()

◆ add_camp()

◆ add_computer()

◆ add_corpse()

◆ add_field()

◆ add_item() [1/2]

◆ add_item() [2/2]

◆ add_item_or_charges() [1/2]

◆ add_item_or_charges() [2/2]

◆ add_light_from_items()

◆ add_light_source()

◆ add_roofs()

◆ add_spawn()

◆ add_splash()

◆ add_splatter()

◆ add_splatter_trail()

◆ add_vehicle() [1/4]

◆ add_vehicle() [2/4]

◆ add_vehicle() [3/4]

◆ add_vehicle() [4/4]

◆ add_vehicle_to_cache()

◆ add_vehicle_to_map()

◆ adjust_radiation() [1/2]

◆ adjust_radiation() [2/2]

◆ ambient_light_at()

◆ apparent_light_at()

◆ apparent_light_helper()

◆ apply_character_light()

◆ apply_directional_light()

◆ apply_faction_ownership()

◆ apply_light_arc()

◆ apply_light_ray()

◆ apply_light_source()

◆ apply_vision_transparency_cache()

◆ bash()

◆ bash_field()

◆ bash_furn_success()

◆ bash_items()

◆ bash_rating() [1/2]

◆ bash_rating() [2/2]

◆ bash_rating_internal()

◆ bash_resistance() [1/2]

◆ bash_resistance() [2/2]

◆ bash_strength() [1/2]

◆ bash_strength() [2/2]

◆ bash_ter_furn()

◆ bash_ter_success()

◆ bash_vehicle()

◆ batter()

◆ board_vehicle()

◆ build_floor_cache()

◆ build_floor_caches()

◆ build_map_cache()

◆ build_obstacle_cache()

◆ build_outside_cache()

◆ build_seen_cache()

◆ build_sunlight_cache()

◆ build_transparency_cache()

◆ build_vision_transparency_cache()

◆ burn_body_part()

◆ calc_max_populated_zlev()

◆ can_move_furniture()

◆ can_put_items() [1/2]